astro-integration-pocketbase 1.0.0 → 1.2.0-next.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "astro-integration-pocketbase",
-  "version": "1.0.0",
+  "version": "1.2.0-next.1",
   "license": "MIT",
   "author": "Luis Wolf <development@pawcode.de> (https://pawcode.de)",
   "homepage": "https://github.com/pawcoding/astro-integration-pocketbase",

package/src/core/refresh-collections-realtime.ts

@@ -2,6 +2,7 @@ import type { BaseIntegrationHooks } from "astro";
 import { EventSource } from "eventsource";
 import type { PocketBaseIntegrationOptions } from "../types/pocketbase-integration-options.type";
 import { getSuperuserToken } from "../utils/get-superuser-token";
+import { mapCollectionsToWatch } from "../utils/map-collections-to-watch";
 
 export function refreshCollectionsRealtime(
   {
@@ -16,9 +17,11 @@ export function refreshCollectionsRealtime(
   }: Parameters<BaseIntegrationHooks["astro:server:setup"]>[0]
 ): EventSource | undefined {
   // Check if collections should be watched
-  if (!collectionsToWatch || collectionsToWatch.length === 0) {
+  const collectionsMap = mapCollectionsToWatch(collectionsToWatch);
+  if (!collectionsMap) {
     return undefined;
   }
+  const remoteCollections = [...collectionsMap.keys()];
 
   // Check if content loader is used
   if (!refreshContent) {
@@ -65,7 +68,7 @@ export function refreshCollectionsRealtime(
   };
 
   // Add event listeners for all collections
-  for (const collection of collectionsToWatch) {
+  for (const collection of remoteCollections) {
     eventSource.addEventListener(`${collection}/*`, async () => {
       // Do not refresh if the refresh is disabled
       if (!refreshEnabled) {
@@ -76,8 +79,10 @@ export function refreshCollectionsRealtime(
       logger.info(`Received update for ${collection}. Refreshing content...`);
       await refreshContent({
         loaders: ["pocketbase-loader"],
-        // TODO: add context to refresh one or all collections
-        context: {}
+        context: {
+          source: "astro-integration-pocketbase",
+          collection: collectionsMap.get(collection)
+        }
       });
     });
   }
@@ -106,7 +111,7 @@ export function refreshCollectionsRealtime(
       },
       body: JSON.stringify({
         clientId: clientId,
-        subscriptions: collectionsToWatch.map((collection) => `${collection}/*`)
+        subscriptions: remoteCollections.map((collection) => `${collection}/*`)
       })
     });
 
@@ -121,7 +126,7 @@ export function refreshCollectionsRealtime(
     if (!wasConnectedOnce) {
       wasConnectedOnce = true;
       logger.info(
-        `Subscribed to PocketBase realtime API. Waiting for updates on ${collectionsToWatch.join(
+        `Subscribed to PocketBase realtime API. Waiting for updates on ${remoteCollections.join(
           ", "
         )}.`
       );

package/src/core/refresh-collections.ts

@@ -26,8 +26,9 @@ export function handleRefreshCollections({
     logger.info("Refreshing content loaded by PocketBase loader");
     await refreshContent({
       loaders: ["pocketbase-loader"],
-      // TODO: add context to refresh one or all collections
-      context: {}
+      context: {
+        source: "astro-integration-pocketbase"
+      }
     });
 
     // Reset the loading state in the toolbar

package/src/types/pocketbase-integration-options.type.ts

@@ -23,6 +23,28 @@ export interface PocketBaseIntegrationOptions {
   /**
    * List of PocketBase collections to watch for changes.
    * When an entry in one of these collections changes, the content will be reloaded.
+   *
+   * Example:
+   * ```ts
+   * collectionsToWatch: ["users", "posts"]
+   * ```
+   *
+   * For advanced usage, you can specify a map where the key is the collection that is used to load the content.
+   * The value can be:
+   * - `true` to watch the collection itself for changes (base collection)
+   * - an array of strings to watch multiple collections for changes (view collection)
+   *
+   * These advanced options are especially useful when you're working with view collections.
+   * [View collections](https://pocketbase.io/docs/collections/#view-collection) don't emit events when their
+   * entries change, since they are based on other collections.
+   *
+   * Example:
+   * ```ts
+   * collectionsToWatch: {
+   *  "users": true,
+   *  "postings": ["posts", "comments"]
+   * }
+   * ```
    */
-  collectionsToWatch?: Array<string>;
+  collectionsToWatch?: Array<string> | Record<string, true | Array<string>>;
 }

package/src/utils/map-collections-to-watch.ts

@@ -0,0 +1,53 @@
+import type { PocketBaseIntegrationOptions } from "../types/pocketbase-integration-options.type";
+import { pushToMapArray } from "./push-to-map-array";
+
+/**
+ * Create a map of remote collections to watch.
+ * Each key in the map represents a remote collection to subscribe to.
+ * The value is an array of local collections that should be refreshed when an entry in the remote collection changes.
+ */
+export function mapCollectionsToWatch(
+  collectionsToWatch: PocketBaseIntegrationOptions["collectionsToWatch"]
+): Map<string, Array<string>> | undefined {
+  // Check if collections should be watched
+  if (!collectionsToWatch) {
+    return;
+  }
+
+  // Check if collectionsToWatch is an array
+  if (Array.isArray(collectionsToWatch)) {
+    // Check if the array is empty
+    if (collectionsToWatch.length === 0) {
+      return;
+    }
+
+    // Create a map where each collection is watched by itself
+    return new Map(
+      collectionsToWatch.map((collection) => [collection, [collection]])
+    );
+  }
+
+  // Check if collectionsToWatch is an empty object
+  if (Object.keys(collectionsToWatch).length === 0) {
+    return;
+  }
+
+  // Map collections to watch
+  const collectionsMap = new Map<string, Array<string>>();
+  for (const localCollection in collectionsToWatch) {
+    const watch = collectionsToWatch[localCollection];
+
+    // Check if collection should be watched by itself
+    if (watch === true) {
+      pushToMapArray(collectionsMap, localCollection, localCollection);
+      continue;
+    }
+
+    // Collection should be watched by multiple collections
+    for (const remoteCollection of watch) {
+      pushToMapArray(collectionsMap, remoteCollection, localCollection);
+    }
+  }
+
+  return collectionsMap;
+}

package/src/utils/push-to-map-array.ts

@@ -0,0 +1,14 @@
+/**
+ * Adds a value to an array in a map. If the key does not exist, it will be created.
+ */
+export function pushToMapArray<TKey, TArray>(
+  map: Map<TKey, Array<TArray>>,
+  key: TKey,
+  value: TArray
+): void {
+  if (map.has(key)) {
+    map.get(key)!.push(value);
+  } else {
+    map.set(key, [value]);
+  }
+}