n8n-nodes-pocketbase 2.3.1 → 2.3.3

package/dist/nodes/PocketbaseTrigger/PocketbaseTrigger.node.js

@@ -1,239 +1,669 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PocketbaseTrigger = void 0;
-const n8n_workflow_1 = require("n8n-workflow");
-const eventsource_1 = require("eventsource");
-const LoadOptions_1 = require("../Common/LoadOptions");
-class PocketbaseTrigger {
-    constructor() {
-        this.description = {
-            displayName: "Pocketbase (Beta) Trigger",
-            name: "pocketbaseTrigger",
-            icon: { light: "file:pocketbaseTrigger.svg", dark: "file:pocketbaseTrigger.dark.svg" },
-            group: ["trigger"],
-            version: 1,
-            description: "Handle Pocketbase events via SSE (Beta)",
-            defaults: {
-                name: "Pocketbase Trigger",
-            },
-            inputs: [],
-            outputs: [n8n_workflow_1.NodeConnectionTypes.Main],
-            credentials: [
-                {
-                    name: "pocketbaseHttpApi",
-                    required: true,
-                },
-            ],
-            properties: [
-                {
-                    displayName: "Collection Name",
-                    name: "collection",
-                    type: "options",
-                    typeOptions: {
-                        loadOptionsMethod: "getCollections",
-                    },
-                    default: "",
-                    required: true,
-                    description: "The name of the collection to watch for changes",
-                },
-                {
-                    displayName: "Events",
-                    name: "events",
-                    type: "multiOptions",
-                    options: [
-                        {
-                            name: "Create",
-                            value: "create",
-                        },
-                        {
-                            name: "Update",
-                            value: "update",
-                        },
-                        {
-                            name: "Delete",
-                            value: "delete",
-                        },
-                    ],
-                    default: ["create", "update", "delete"],
-                    required: true,
-                    description: "The events to trigger the node",
-                },
-            ],
-        };
-        this.methods = {
-            loadOptions: LoadOptions_1.LoadOptions,
-        };
-    }
-    async trigger() {
-        const credentials = await this.getCredentials("pocketbaseHttpApi");
-        const baseUrl = credentials.url.replace(/\/$/, "");
-        const collection = this.getNodeParameter("collection");
-        const events = this.getNodeParameter("events");
-        const { closeFunction } = subscribeToPocketbaseSSE.call(this, baseUrl, collection, events);
-        return {
-            closeFunction,
-            manualTriggerFunction: async () => {
-                const sampleData = {
-                    __action: "create",
-                    id: "sample-id",
-                    collectionId: "sample-collection-id",
-                    collectionName: collection,
-                    created: new Date().toISOString(),
-                    updated: new Date().toISOString(),
-                };
-                this.emit([this.helpers.returnJsonArray(sampleData)]);
-            },
-        };
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __commonJS = (cb, mod) => function __require() {
+  try {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  } catch (e) {
+    throw mod = 0, e;
+  }
+};
+
+// node_modules/eventsource-parser/dist/index.cjs
+var require_dist = __commonJS({
+  "node_modules/eventsource-parser/dist/index.cjs"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    var ParseError = class extends Error {
+      constructor(message, options) {
+        super(message), this.name = "ParseError", this.type = options.type, this.field = options.field, this.value = options.value, this.line = options.line;
+      }
+    };
+    function noop(_arg) {
     }
-}
-exports.PocketbaseTrigger = PocketbaseTrigger;
-function subscribeToPocketbaseSSE(baseUrl, collection, events) {
-    let es = null;
-    let isClosed = false;
-    let isReconnecting = false;
-    let reconnectTimeout = null;
-    let stabilityTimer = null;
-    let reconnectAttempts = 0;
-    const MAX_RECONNECT_ATTEMPTS = 50;
-    let consecutiveFailures = 0;
-    const onConnect = async (e) => {
-        try {
-            const data = JSON.parse(e.data);
-            const clientId = data.clientId;
-            await this.helpers.httpRequestWithAuthentication.call(this, "pocketbaseHttpApi", {
-                method: "POST",
-                url: `${baseUrl}/api/realtime`,
-                body: {
-                    clientId,
-                    subscriptions: [collection],
-                },
-            });
-            if (stabilityTimer)
-                clearTimeout(stabilityTimer);
-            stabilityTimer = setTimeout(() => {
-                reconnectAttempts = 0;
-                consecutiveFailures = 0;
-                stabilityTimer = null;
-            }, 5000);
-        }
-        catch (error) {
-            this.logger.error("Failed to connect to PocketBase SSE", { error, collection });
-            const normalizedError = error instanceof Error ? error : new Error(String(error || "Unknown error during connect"));
-            if (consecutiveFailures === 0) {
-                this.emitError(normalizedError);
-            }
-            consecutiveFailures++;
-            reconnect();
+    function createParser(callbacks) {
+      if (typeof callbacks == "function")
+        throw new TypeError(
+          "`callbacks` must be an object, got a function instead. Did you mean `{onEvent: fn}`?"
+        );
+      const { onEvent = noop, onError = noop, onRetry = noop, onComment } = callbacks;
+      let incompleteLine = "", isFirstChunk = true, id, data = "", eventType = "";
+      function feed(newChunk) {
+        const chunk = isFirstChunk ? newChunk.replace(/^\xEF\xBB\xBF/, "") : newChunk, [complete, incomplete] = splitLines(`${incompleteLine}${chunk}`);
+        for (const line of complete)
+          parseLine(line);
+        incompleteLine = incomplete, isFirstChunk = false;
+      }
+      function parseLine(line) {
+        if (line === "") {
+          dispatchEvent();
+          return;
         }
-    };
-    const onError = (error) => {
-        if (stabilityTimer) {
-            clearTimeout(stabilityTimer);
-            stabilityTimer = null;
+        if (line.startsWith(":")) {
+          onComment && onComment(line.slice(line.startsWith(": ") ? 2 : 1));
+          return;
         }
-        this.logger.error("PocketBase SSE connection failure", {
-            error,
-            baseUrl,
-        });
-        const normalizedError = new Error((error && error.message) || "PocketBase SSE connection failure");
-        if (error && error.code)
-            normalizedError.code = error.code;
-        if (error && error.status)
-            normalizedError.status = error.status;
-        normalizedError.originalErrorEvent = error;
-        if (consecutiveFailures === 0) {
-            this.emitError(normalizedError);
+        const fieldSeparatorIndex = line.indexOf(":");
+        if (fieldSeparatorIndex !== -1) {
+          const field = line.slice(0, fieldSeparatorIndex), offset = line[fieldSeparatorIndex + 1] === " " ? 2 : 1, value = line.slice(fieldSeparatorIndex + offset);
+          processField(field, value, line);
+          return;
         }
-        consecutiveFailures++;
-        reconnect();
-    };
-    const onMessage = (e) => {
-        var _a;
-        try {
-            const data = JSON.parse(e.data);
-            if (events.includes(data.action) && data.record) {
-                const output = {
-                    ...data.record,
-                };
-                if ("action" in output) {
-                    output.__original_action = output.action;
-                }
-                output.__action = data.action;
-                this.emit([this.helpers.returnJsonArray(output)]);
-            }
+        processField(line, "", line);
+      }
+      function processField(field, value, line) {
+        switch (field) {
+          case "event":
+            eventType = value;
+            break;
+          case "data":
+            data = `${data}${value}
+`;
+            break;
+          case "id":
+            id = value.includes("\0") ? void 0 : value;
+            break;
+          case "retry":
+            /^\d+$/.test(value) ? onRetry(parseInt(value, 10)) : onError(
+              new ParseError(`Invalid \`retry\` value: "${value}"`, {
+                type: "invalid-retry",
+                value,
+                line
+              })
+            );
+            break;
+          default:
+            onError(
+              new ParseError(
+                `Unknown field "${field.length > 20 ? `${field.slice(0, 20)}\u2026` : field}"`,
+                { type: "unknown-field", field, value, line }
+              )
+            );
+            break;
         }
-        catch (error) {
-            const rawData = String((_a = e === null || e === void 0 ? void 0 : e.data) !== null && _a !== void 0 ? _a : "");
-            const redactedPreview = rawData
-                .replace(/"(password|token|secret|passwordConfirm|apiKey|accessToken|authorization|bearer)":\s*"(?:[^"\\]|\\.)*"/gi, '"$1": "[REDACTED]"')
-                .replace(/"email":\s*"(?:[^"\\]|\\.)*"/gi, '"email": "[REDACTED]"')
-                .replace(/[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g, "[REDACTED]")
-                .substring(0, 200);
-            this.logger.error("Failed to parse PocketBase SSE message", {
-                error,
-                redactedPreview,
-                collection,
-            });
+      }
+      function dispatchEvent() {
+        data.length > 0 && onEvent({
+          id,
+          event: eventType || void 0,
+          // If the data buffer's last character is a U+000A LINE FEED (LF) character,
+          // then remove the last character from the data buffer.
+          data: data.endsWith(`
+`) ? data.slice(0, -1) : data
+        }), id = void 0, data = "", eventType = "";
+      }
+      function reset(options = {}) {
+        incompleteLine && options.consume && parseLine(incompleteLine), isFirstChunk = true, id = void 0, data = "", eventType = "", incompleteLine = "";
+      }
+      return { feed, reset };
+    }
+    function splitLines(chunk) {
+      const lines = [];
+      let incompleteLine = "", searchIndex = 0;
+      for (; searchIndex < chunk.length; ) {
+        const crIndex = chunk.indexOf("\r", searchIndex), lfIndex = chunk.indexOf(`
+`, searchIndex);
+        let lineEnd = -1;
+        if (crIndex !== -1 && lfIndex !== -1 ? lineEnd = Math.min(crIndex, lfIndex) : crIndex !== -1 ? crIndex === chunk.length - 1 ? lineEnd = -1 : lineEnd = crIndex : lfIndex !== -1 && (lineEnd = lfIndex), lineEnd === -1) {
+          incompleteLine = chunk.slice(searchIndex);
+          break;
+        } else {
+          const line = chunk.slice(searchIndex, lineEnd);
+          lines.push(line), searchIndex = lineEnd + 1, chunk[searchIndex - 1] === "\r" && chunk[searchIndex] === `
+` && searchIndex++;
         }
+      }
+      return [lines, incompleteLine];
+    }
+    exports2.ParseError = ParseError;
+    exports2.createParser = createParser;
+  }
+});
+
+// node_modules/eventsource/dist/index.cjs
+var require_dist2 = __commonJS({
+  "node_modules/eventsource/dist/index.cjs"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    var eventsourceParser = require_dist();
+    var ErrorEvent = class extends Event {
+      /**
+       * Constructs a new `ErrorEvent` instance. This is typically not called directly,
+       * but rather emitted by the `EventSource` object when an error occurs.
+       *
+       * @param type - The type of the event (should be "error")
+       * @param errorEventInitDict - Optional properties to include in the error event
+       */
+      constructor(type, errorEventInitDict) {
+        var _a, _b;
+        super(type), this.code = (_a = errorEventInitDict == null ? void 0 : errorEventInitDict.code) != null ? _a : void 0, this.message = (_b = errorEventInitDict == null ? void 0 : errorEventInitDict.message) != null ? _b : void 0;
+      }
+      /**
+       * Node.js "hides" the `message` and `code` properties of the `ErrorEvent` instance,
+       * when it is `console.log`'ed. This makes it harder to debug errors. To ease debugging,
+       * we explicitly include the properties in the `inspect` method.
+       *
+       * This is automatically called by Node.js when you `console.log` an instance of this class.
+       *
+       * @param _depth - The current depth
+       * @param options - The options passed to `util.inspect`
+       * @param inspect - The inspect function to use (prevents having to import it from `util`)
+       * @returns A string representation of the error
+       */
+      [/* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom")](_depth, options, inspect) {
+        return inspect(inspectableError(this), options);
+      }
+      /**
+       * Deno "hides" the `message` and `code` properties of the `ErrorEvent` instance,
+       * when it is `console.log`'ed. This makes it harder to debug errors. To ease debugging,
+       * we explicitly include the properties in the `inspect` method.
+       *
+       * This is automatically called by Deno when you `console.log` an instance of this class.
+       *
+       * @param inspect - The inspect function to use (prevents having to import it from `util`)
+       * @param options - The options passed to `Deno.inspect`
+       * @returns A string representation of the error
+       */
+      [/* @__PURE__ */ Symbol.for("Deno.customInspect")](inspect, options) {
+        return inspect(inspectableError(this), options);
+      }
     };
-    const connect = () => {
-        if (isClosed)
-            return;
-        isReconnecting = false;
-        es = new eventsource_1.EventSource(`${baseUrl}/api/realtime`);
-        es.addEventListener("PB_CONNECT", onConnect);
-        es.addEventListener("error", onError);
-        es.addEventListener(collection, onMessage);
+    function syntaxError(message) {
+      const DomException = globalThis.DOMException;
+      return typeof DomException == "function" ? new DomException(message, "SyntaxError") : new SyntaxError(message);
+    }
+    function flattenError(err) {
+      return err instanceof Error ? "errors" in err && Array.isArray(err.errors) ? err.errors.map(flattenError).join(", ") : "cause" in err && err.cause instanceof Error ? `${err}: ${flattenError(err.cause)}` : err.message : `${err}`;
+    }
+    function inspectableError(err) {
+      return {
+        type: err.type,
+        message: err.message,
+        code: err.code,
+        defaultPrevented: err.defaultPrevented,
+        cancelable: err.cancelable,
+        timeStamp: err.timeStamp
+      };
+    }
+    var __typeError = (msg) => {
+      throw TypeError(msg);
     };
-    const reconnect = () => {
-        if (isClosed || isReconnecting)
+    var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+    var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+    var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+    var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), member.set(obj, value), value);
+    var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+    var _readyState;
+    var _url;
+    var _redirectUrl;
+    var _withCredentials;
+    var _fetch;
+    var _reconnectInterval;
+    var _reconnectTimer;
+    var _lastEventId;
+    var _controller;
+    var _parser;
+    var _onError;
+    var _onMessage;
+    var _onOpen;
+    var _EventSource_instances;
+    var connect_fn;
+    var _onFetchResponse;
+    var _onFetchError;
+    var getRequestOptions_fn;
+    var _onEvent;
+    var _onRetryChange;
+    var failConnection_fn;
+    var scheduleReconnect_fn;
+    var _reconnect;
+    var EventSource = class extends EventTarget {
+      constructor(url, eventSourceInitDict) {
+        var _a, _b;
+        super(), __privateAdd(this, _EventSource_instances), this.CONNECTING = 0, this.OPEN = 1, this.CLOSED = 2, __privateAdd(this, _readyState), __privateAdd(this, _url), __privateAdd(this, _redirectUrl), __privateAdd(this, _withCredentials), __privateAdd(this, _fetch), __privateAdd(this, _reconnectInterval), __privateAdd(this, _reconnectTimer), __privateAdd(this, _lastEventId, null), __privateAdd(this, _controller), __privateAdd(this, _parser), __privateAdd(this, _onError, null), __privateAdd(this, _onMessage, null), __privateAdd(this, _onOpen, null), __privateAdd(this, _onFetchResponse, async (response) => {
+          var _a2;
+          __privateGet(this, _parser).reset();
+          const { body, redirected, status, headers } = response;
+          if (status === 204) {
+            __privateMethod(this, _EventSource_instances, failConnection_fn).call(this, "Server sent HTTP 204, not reconnecting", 204), this.close();
+            return;
+          }
+          if (redirected ? __privateSet(this, _redirectUrl, new URL(response.url)) : __privateSet(this, _redirectUrl, void 0), status !== 200) {
+            __privateMethod(this, _EventSource_instances, failConnection_fn).call(this, `Non-200 status code (${status})`, status);
+            return;
+          }
+          if (!(headers.get("content-type") || "").startsWith("text/event-stream")) {
+            __privateMethod(this, _EventSource_instances, failConnection_fn).call(this, 'Invalid content type, expected "text/event-stream"', status);
+            return;
+          }
+          if (__privateGet(this, _readyState) === this.CLOSED)
+            return;
+          __privateSet(this, _readyState, this.OPEN);
+          const openEvent = new Event("open");
+          if ((_a2 = __privateGet(this, _onOpen)) == null || _a2.call(this, openEvent), this.dispatchEvent(openEvent), typeof body != "object" || !body || !("getReader" in body)) {
+            __privateMethod(this, _EventSource_instances, failConnection_fn).call(this, "Invalid response body, expected a web ReadableStream", status), this.close();
             return;
-        isReconnecting = true;
-        if (stabilityTimer) {
-            clearTimeout(stabilityTimer);
-            stabilityTimer = null;
+          }
+          const decoder = new TextDecoder(), reader = body.getReader();
+          let open = true;
+          do {
+            const { done, value } = await reader.read();
+            value && __privateGet(this, _parser).feed(decoder.decode(value, { stream: !done })), done && (open = false, __privateGet(this, _parser).reset(), __privateMethod(this, _EventSource_instances, scheduleReconnect_fn).call(this));
+          } while (open);
+        }), __privateAdd(this, _onFetchError, (err) => {
+          __privateSet(this, _controller, void 0), !(err.name === "AbortError" || err.type === "aborted") && __privateMethod(this, _EventSource_instances, scheduleReconnect_fn).call(this, flattenError(err));
+        }), __privateAdd(this, _onEvent, (event) => {
+          typeof event.id == "string" && __privateSet(this, _lastEventId, event.id);
+          const messageEvent = new MessageEvent(event.event || "message", {
+            data: event.data,
+            origin: __privateGet(this, _redirectUrl) ? __privateGet(this, _redirectUrl).origin : __privateGet(this, _url).origin,
+            lastEventId: event.id || ""
+          });
+          __privateGet(this, _onMessage) && (!event.event || event.event === "message") && __privateGet(this, _onMessage).call(this, messageEvent), this.dispatchEvent(messageEvent);
+        }), __privateAdd(this, _onRetryChange, (value) => {
+          __privateSet(this, _reconnectInterval, value);
+        }), __privateAdd(this, _reconnect, () => {
+          __privateSet(this, _reconnectTimer, void 0), __privateGet(this, _readyState) === this.CONNECTING && __privateMethod(this, _EventSource_instances, connect_fn).call(this);
+        });
+        try {
+          if (url instanceof URL)
+            __privateSet(this, _url, url);
+          else if (typeof url == "string")
+            __privateSet(this, _url, new URL(url, getBaseURL()));
+          else
+            throw new Error("Invalid URL");
+        } catch {
+          throw syntaxError("An invalid or illegal string was specified");
         }
-        if (es) {
-            es.removeEventListener("PB_CONNECT", onConnect);
-            es.removeEventListener("error", onError);
-            es.removeEventListener(collection, onMessage);
-            es.close();
-            es = null;
+        __privateSet(this, _parser, eventsourceParser.createParser({
+          onEvent: __privateGet(this, _onEvent),
+          onRetry: __privateGet(this, _onRetryChange)
+        })), __privateSet(this, _readyState, this.CONNECTING), __privateSet(this, _reconnectInterval, 3e3), __privateSet(this, _fetch, (_a = eventSourceInitDict == null ? void 0 : eventSourceInitDict.fetch) != null ? _a : globalThis.fetch), __privateSet(this, _withCredentials, (_b = eventSourceInitDict == null ? void 0 : eventSourceInitDict.withCredentials) != null ? _b : false), __privateMethod(this, _EventSource_instances, connect_fn).call(this);
+      }
+      /**
+       * Returns the state of this EventSource object's connection. It can have the values described below.
+       *
+       * [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventSource/readyState)
+       *
+       * Note: typed as `number` instead of `0 | 1 | 2` for compatibility with the `EventSource` interface,
+       * defined in the TypeScript `dom` library.
+       *
+       * @public
+       */
+      get readyState() {
+        return __privateGet(this, _readyState);
+      }
+      /**
+       * Returns the URL providing the event stream.
+       *
+       * [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventSource/url)
+       *
+       * @public
+       */
+      get url() {
+        return __privateGet(this, _url).href;
+      }
+      /**
+       * Returns true if the credentials mode for connection requests to the URL providing the event stream is set to "include", and false otherwise.
+       *
+       * [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventSource/withCredentials)
+       */
+      get withCredentials() {
+        return __privateGet(this, _withCredentials);
+      }
+      /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventSource/error_event) */
+      get onerror() {
+        return __privateGet(this, _onError);
+      }
+      set onerror(value) {
+        __privateSet(this, _onError, value);
+      }
+      /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventSource/message_event) */
+      get onmessage() {
+        return __privateGet(this, _onMessage);
+      }
+      set onmessage(value) {
+        __privateSet(this, _onMessage, value);
+      }
+      /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventSource/open_event) */
+      get onopen() {
+        return __privateGet(this, _onOpen);
+      }
+      set onopen(value) {
+        __privateSet(this, _onOpen, value);
+      }
+      addEventListener(type, listener, options) {
+        const listen = listener;
+        super.addEventListener(type, listen, options);
+      }
+      removeEventListener(type, listener, options) {
+        const listen = listener;
+        super.removeEventListener(type, listen, options);
+      }
+      /**
+       * Aborts any instances of the fetch algorithm started for this EventSource object, and sets the readyState attribute to CLOSED.
+       *
+       * [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventSource/close)
+       *
+       * @public
+       */
+      close() {
+        __privateGet(this, _reconnectTimer) && clearTimeout(__privateGet(this, _reconnectTimer)), __privateGet(this, _readyState) !== this.CLOSED && (__privateGet(this, _controller) && __privateGet(this, _controller).abort(), __privateSet(this, _readyState, this.CLOSED), __privateSet(this, _controller, void 0));
+      }
+    };
+    _readyState = /* @__PURE__ */ new WeakMap(), _url = /* @__PURE__ */ new WeakMap(), _redirectUrl = /* @__PURE__ */ new WeakMap(), _withCredentials = /* @__PURE__ */ new WeakMap(), _fetch = /* @__PURE__ */ new WeakMap(), _reconnectInterval = /* @__PURE__ */ new WeakMap(), _reconnectTimer = /* @__PURE__ */ new WeakMap(), _lastEventId = /* @__PURE__ */ new WeakMap(), _controller = /* @__PURE__ */ new WeakMap(), _parser = /* @__PURE__ */ new WeakMap(), _onError = /* @__PURE__ */ new WeakMap(), _onMessage = /* @__PURE__ */ new WeakMap(), _onOpen = /* @__PURE__ */ new WeakMap(), _EventSource_instances = /* @__PURE__ */ new WeakSet(), /**
+    * Connect to the given URL and start receiving events
+    *
+    * @internal
+    */
+    connect_fn = function() {
+      __privateSet(this, _readyState, this.CONNECTING), __privateSet(this, _controller, new AbortController()), __privateGet(this, _fetch)(__privateGet(this, _url), __privateMethod(this, _EventSource_instances, getRequestOptions_fn).call(this)).then(__privateGet(this, _onFetchResponse)).catch(__privateGet(this, _onFetchError));
+    }, _onFetchResponse = /* @__PURE__ */ new WeakMap(), _onFetchError = /* @__PURE__ */ new WeakMap(), /**
+    * Get request options for the `fetch()` request
+    *
+    * @returns The request options
+    * @internal
+    */
+    getRequestOptions_fn = function() {
+      var _a;
+      const init = {
+        // [spec] Let `corsAttributeState` be `Anonymous`…
+        // [spec] …will have their mode set to "cors"…
+        mode: "cors",
+        redirect: "follow",
+        headers: { Accept: "text/event-stream", ...__privateGet(this, _lastEventId) ? { "Last-Event-ID": __privateGet(this, _lastEventId) } : void 0 },
+        cache: "no-store",
+        signal: (_a = __privateGet(this, _controller)) == null ? void 0 : _a.signal
+      };
+      return "window" in globalThis && (init.credentials = this.withCredentials ? "include" : "same-origin"), init;
+    }, _onEvent = /* @__PURE__ */ new WeakMap(), _onRetryChange = /* @__PURE__ */ new WeakMap(), /**
+    * Handles the process referred to in the EventSource specification as "failing a connection".
+    *
+    * @param error - The error causing the connection to fail
+    * @param code - The HTTP status code, if available
+    * @internal
+    */
+    failConnection_fn = function(message, code) {
+      var _a;
+      __privateGet(this, _readyState) !== this.CLOSED && __privateSet(this, _readyState, this.CLOSED);
+      const errorEvent = new ErrorEvent("error", { code, message });
+      (_a = __privateGet(this, _onError)) == null || _a.call(this, errorEvent), this.dispatchEvent(errorEvent);
+    }, /**
+    * Schedules a reconnection attempt against the EventSource endpoint.
+    *
+    * @param message - The error causing the connection to fail
+    * @param code - The HTTP status code, if available
+    * @internal
+    */
+    scheduleReconnect_fn = function(message, code) {
+      var _a;
+      if (__privateGet(this, _readyState) === this.CLOSED)
+        return;
+      __privateSet(this, _readyState, this.CONNECTING);
+      const errorEvent = new ErrorEvent("error", { code, message });
+      (_a = __privateGet(this, _onError)) == null || _a.call(this, errorEvent), this.dispatchEvent(errorEvent), __privateSet(this, _reconnectTimer, setTimeout(__privateGet(this, _reconnect), __privateGet(this, _reconnectInterval)));
+    }, _reconnect = /* @__PURE__ */ new WeakMap(), /**
+    * ReadyState representing an EventSource currently trying to connect
+    *
+    * @public
+    */
+    EventSource.CONNECTING = 0, /**
+    * ReadyState representing an EventSource connection that is open (eg connected)
+    *
+    * @public
+    */
+    EventSource.OPEN = 1, /**
+    * ReadyState representing an EventSource connection that is closed (eg disconnected)
+    *
+    * @public
+    */
+    EventSource.CLOSED = 2;
+    Object.defineProperty(EventSource, /* @__PURE__ */ Symbol.for("eventsource.supports-fetch-override"), {
+      value: true,
+      writable: false,
+      configurable: false,
+      enumerable: false
+    });
+    function getBaseURL() {
+      const doc = "document" in globalThis ? globalThis.document : void 0;
+      return doc && typeof doc == "object" && "baseURI" in doc && typeof doc.baseURI == "string" ? doc.baseURI : void 0;
+    }
+    exports2.ErrorEvent = ErrorEvent;
+    exports2.EventSource = EventSource;
+  }
+});
+
+// dist/nodes/PocketbaseTrigger/PocketbaseTrigger.node.js
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PocketbaseTrigger = void 0;
+var n8n_workflow_1 = require("n8n-workflow");
+var eventsource_1 = require_dist2();
+var LoadOptions_1 = require("../Common/LoadOptions");
+var PocketbaseTrigger = class {
+  constructor() {
+    this.description = {
+      displayName: "Pocketbase (Beta) Trigger",
+      name: "pocketbaseTrigger",
+      icon: { light: "file:pocketbaseTrigger.svg", dark: "file:pocketbaseTrigger.dark.svg" },
+      group: ["trigger"],
+      version: 1,
+      description: "Handle Pocketbase events via SSE (Beta)",
+      subtitle: '={{$parameter["collection"]}}',
+      defaults: {
+        name: "Pocketbase Trigger"
+      },
+      inputs: [],
+      outputs: [n8n_workflow_1.NodeConnectionTypes.Main],
+      credentials: [
+        {
+          name: "pocketbaseHttpApi",
+          required: true
         }
-        if (reconnectAttempts >= MAX_RECONNECT_ATTEMPTS) {
-            this.logger.error("PocketBase trigger permanently closed after max reconnection attempts", {
-                baseUrl,
-                collection,
-                reconnectAttempts,
-            });
-            this.emitError(new Error(`PocketBase SSE: Maximum reconnection attempts (${MAX_RECONNECT_ATTEMPTS}) reached`));
-            isClosed = true;
-            isReconnecting = false;
-            return;
+      ],
+      properties: [
+        {
+          displayName: "Collection Name or ID",
+          name: "collection",
+          type: "options",
+          typeOptions: {
+            loadOptionsMethod: "getCollections"
+          },
+          default: "",
+          required: true,
+          description: 'The name of the collection to watch for changes. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>.'
+        },
+        {
+          displayName: "Events",
+          name: "events",
+          type: "multiOptions",
+          options: [
+            {
+              name: "Create",
+              value: "create"
+            },
+            {
+              name: "Update",
+              value: "update"
+            },
+            {
+              name: "Delete",
+              value: "delete"
+            }
+          ],
+          default: ["create", "update", "delete"],
+          required: true,
+          description: "The events to trigger the node"
         }
-        const baseDelay = Math.min(1000 * Math.pow(2, reconnectAttempts), 30000);
-        const jitter = Math.random() * 1000;
-        const delay = baseDelay + jitter;
-        reconnectAttempts++;
-        reconnectTimeout = setTimeout(connect, delay);
+      ],
+      usableAsTool: true
+    };
+    this.methods = {
+      loadOptions: LoadOptions_1.LoadOptions
     };
-    connect();
+  }
+  async trigger() {
+    const credentials = await this.getCredentials("pocketbaseHttpApi");
+    const baseUrl = credentials.url.replace(/\/$/, "");
+    const collection = this.getNodeParameter("collection");
+    const events = this.getNodeParameter("events");
+    const { closeFunction } = subscribeToPocketbaseSSE.call(this, baseUrl, collection, events);
     return {
-        closeFunction: async () => {
-            isClosed = true;
-            if (reconnectTimeout)
-                clearTimeout(reconnectTimeout);
-            if (stabilityTimer) {
-                clearTimeout(stabilityTimer);
-                stabilityTimer = null;
-            }
-            if (es) {
-                es.removeEventListener("PB_CONNECT", onConnect);
-                es.removeEventListener("error", onError);
-                es.removeEventListener(collection, onMessage);
-                es.close();
-            }
-        },
+      closeFunction,
+      manualTriggerFunction: async () => {
+        const sampleData = {
+          __action: "create",
+          id: "sample-id",
+          collectionId: "sample-collection-id",
+          collectionName: collection,
+          created: (/* @__PURE__ */ new Date()).toISOString(),
+          updated: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        this.emit([this.helpers.returnJsonArray(sampleData)]);
+      }
     };
+  }
+};
+exports.PocketbaseTrigger = PocketbaseTrigger;
+function subscribeToPocketbaseSSE(baseUrl, collection, events) {
+  let es = null;
+  let isClosed = false;
+  let isReconnecting = false;
+  let reconnectTimeout = null;
+  let stabilityTimer = null;
+  let reconnectAttempts = 0;
+  const MAX_RECONNECT_ATTEMPTS = 50;
+  let consecutiveFailures = 0;
+  const onConnect = async (e) => {
+    try {
+      const data = JSON.parse(e.data);
+      const clientId = data.clientId;
+      await this.helpers.httpRequestWithAuthentication.call(this, "pocketbaseHttpApi", {
+        method: "POST",
+        url: `${baseUrl}/api/realtime`,
+        body: {
+          clientId,
+          subscriptions: [collection]
+        }
+      });
+      if (stabilityTimer)
+        clearTimeout(stabilityTimer);
+      stabilityTimer = setTimeout(() => {
+        reconnectAttempts = 0;
+        consecutiveFailures = 0;
+        stabilityTimer = null;
+      }, 5e3);
+    } catch (error) {
+      this.logger.error("Failed to connect to PocketBase SSE", { error, collection });
+      const normalizedError = error instanceof Error ? error : new Error(String(error || "Unknown error during connect"));
+      if (consecutiveFailures === 0) {
+        this.emitError(normalizedError);
+      }
+      consecutiveFailures++;
+      reconnect();
+    }
+  };
+  const onError = (error) => {
+    if (stabilityTimer) {
+      clearTimeout(stabilityTimer);
+      stabilityTimer = null;
+    }
+    this.logger.error("PocketBase SSE connection failure", {
+      error,
+      baseUrl
+    });
+    const normalizedError = new Error(error.message || "PocketBase SSE connection failure");
+    const status = error.status;
+    if (error.code)
+      normalizedError.code = error.code;
+    if (status)
+      normalizedError.status = status;
+    normalizedError.originalErrorEvent = error;
+    if (consecutiveFailures === 0) {
+      this.emitError(normalizedError);
+    }
+    consecutiveFailures++;
+    reconnect();
+  };
+  const onMessage = (e) => {
+    var _a;
+    try {
+      const data = JSON.parse(e.data);
+      if (events.includes(data.action) && data.record) {
+        const output = {
+          ...data.record
+        };
+        if ("action" in output) {
+          output.__original_action = output.action;
+        }
+        output.__action = data.action;
+        this.emit([this.helpers.returnJsonArray(output)]);
+      }
+    } catch (error) {
+      const rawData = String((_a = e === null || e === void 0 ? void 0 : e.data) !== null && _a !== void 0 ? _a : "");
+      const redactedPreview = rawData.replace(/"(password|token|secret|passwordConfirm|apiKey|accessToken|authorization|bearer)":\s*"(?:[^"\\]|\\.)*"/gi, '"$1": "[REDACTED]"').replace(/"email":\s*"(?:[^"\\]|\\.)*"/gi, '"email": "[REDACTED]"').replace(/[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g, "[REDACTED]").substring(0, 200);
+      this.logger.error("Failed to parse PocketBase SSE message", {
+        error,
+        redactedPreview,
+        collection
+      });
+    }
+  };
+  const connect = () => {
+    if (isClosed)
+      return;
+    isReconnecting = false;
+    es = new eventsource_1.EventSource(`${baseUrl}/api/realtime`);
+    es.addEventListener("PB_CONNECT", onConnect);
+    es.addEventListener("error", onError);
+    es.addEventListener(collection, onMessage);
+  };
+  const reconnect = () => {
+    if (isClosed || isReconnecting)
+      return;
+    isReconnecting = true;
+    if (stabilityTimer) {
+      clearTimeout(stabilityTimer);
+      stabilityTimer = null;
+    }
+    if (es) {
+      es.removeEventListener("PB_CONNECT", onConnect);
+      es.removeEventListener("error", onError);
+      es.removeEventListener(collection, onMessage);
+      es.close();
+      es = null;
+    }
+    if (reconnectAttempts >= MAX_RECONNECT_ATTEMPTS) {
+      this.logger.error("PocketBase trigger permanently closed after max reconnection attempts", {
+        baseUrl,
+        collection,
+        reconnectAttempts
+      });
+      this.emitError(new Error(`PocketBase SSE: Maximum reconnection attempts (${MAX_RECONNECT_ATTEMPTS}) reached`));
+      isClosed = true;
+      isReconnecting = false;
+      return;
+    }
+    const baseDelay = Math.min(1e3 * Math.pow(2, reconnectAttempts), 3e4);
+    const jitter = Math.random() * 1e3;
+    const delay = baseDelay + jitter;
+    reconnectAttempts++;
+    reconnectTimeout = setTimeout(connect, delay);
+  };
+  connect();
+  return {
+    closeFunction: async () => {
+      isClosed = true;
+      if (reconnectTimeout)
+        clearTimeout(reconnectTimeout);
+      if (stabilityTimer) {
+        clearTimeout(stabilityTimer);
+        stabilityTimer = null;
+      }
+      if (es) {
+        es.removeEventListener("PB_CONNECT", onConnect);
+        es.removeEventListener("error", onError);
+        es.removeEventListener(collection, onMessage);
+        es.close();
+      }
+    }
+  };
 }
-//# sourceMappingURL=PocketbaseTrigger.node.js.map
+//# sourceMappingURL=PocketbaseTrigger.node.js.map