npm - @bonsae/node-red-salesforce - Versions diffs - 0.1.0 - Mend

@bonsae/node-red-salesforce 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (46) hide show

package/README.md +126 -0
package/examples/1-soql-query.json +103 -0
package/examples/10-streaming-platform-events.json +73 -0
package/examples/11-streaming-change-data-capture.json +73 -0
package/examples/2-dml-create.json +106 -0
package/examples/3-dml-read.json +83 -0
package/examples/4-dml-update.json +83 -0
package/examples/5-dml-delete.json +83 -0
package/examples/6-describe.json +97 -0
package/examples/7-apex-rest.json +99 -0
package/examples/8-bulk-insert.json +63 -0
package/examples/9-bulk-query.json +63 -0
package/icons/salesforce-apex.png +0 -0
package/icons/salesforce-bulk.png +0 -0
package/icons/salesforce-connection.png +0 -0
package/icons/salesforce-describe.png +0 -0
package/icons/salesforce-dml.png +0 -0
package/icons/salesforce-soql.png +0 -0
package/icons/salesforce-streaming.png +0 -0
package/index.d.ts +268 -0
package/index.html +2 -0
package/index.js +14 -0
package/index.mjs +913 -0
package/index.mjs.map +1 -0
package/locales/de/index.html +226 -0
package/locales/de/index.json +154 -0
package/locales/en-US/index.html +226 -0
package/locales/en-US/index.json +154 -0
package/locales/es-ES/index.html +226 -0
package/locales/es-ES/index.json +154 -0
package/locales/fr/index.html +226 -0
package/locales/fr/index.json +154 -0
package/locales/ja/index.html +226 -0
package/locales/ja/index.json +154 -0
package/locales/ko/index.html +226 -0
package/locales/ko/index.json +154 -0
package/locales/pt-BR/index.html +226 -0
package/locales/pt-BR/index.json +154 -0
package/locales/ru/index.html +226 -0
package/locales/ru/index.json +154 -0
package/locales/zh-CN/index.html +226 -0
package/locales/zh-CN/index.json +154 -0
package/locales/zh-TW/index.html +226 -0
package/locales/zh-TW/index.json +154 -0
package/package.json +52 -0
package/resources/index.CfTW8fjc.js +1 -0

package/index.mjs ADDED Viewed

@@ -0,0 +1,913 @@
+var P = Object.defineProperty;
+var J = (r, o, n) => o in r ? P(r, o, { enumerable: !0, configurable: !0, writable: !0, value: n }) : r[o] = n;
+var f = (r, o) => P(r, "name", { value: o, configurable: !0 });
+var i = (r, o, n) => J(r, typeof o != "symbol" ? o + "" : o, n);
+import { fileURLToPath as V } from "url";
+import { dirname as H } from "path";
+import { registerTypes as Y } from "@bonsae/nrg/server";
+import { defineSchema as h, SchemaType as t, ConfigNode as G, IONode as F, defineModule as K } from "@bonsae/nrg/server";
+import W from "jsforce";
+import N from "node:crypto";
+var Q = V(import.meta.url), Lt = H(Q);
+const X = h(
+  {
+    name: t.String({ default: "" }),
+    loginUrl: t.String({
+      default: "https://login.salesforce.com",
+      "x-nrg-form": { icon: "globe" }
+    }),
+    clientId: t.String({
+      default: "",
+      "x-nrg-form": { icon: "key" }
+    }),
+    apiVersion: t.Union(
+      [
+        t.Literal("62.0"),
+        t.Literal("61.0"),
+        t.Literal("60.0"),
+        t.Literal("59.0"),
+        t.Literal("58.0"),
+        t.Literal("57.0"),
+        t.Literal("56.0"),
+        t.Literal("55.0")
+      ],
+      { default: "62.0", "x-nrg-form": { icon: "code-fork" } }
+    ),
+    callbackUrl: t.Optional(
+      t.String({
+        default: "",
+        "x-nrg-form": { icon: "exchange" }
+      })
+    )
+  },
+  { $id: "salesforce-connection:config" }
+), Z = h(
+  {
+    accessToken: t.String({ default: "", format: "password" }),
+    refreshToken: t.String({ default: "", format: "password" }),
+    instanceUrl: t.String({ default: "" })
+  },
+  { $id: "salesforce-connection:credentials" }
+), z = 600 * 1e3, C = /* @__PURE__ */ new Map();
+function B() {
+  return N.randomBytes(32).toString("base64url");
+}
+f(B, "generateCodeVerifier");
+function D(r) {
+  return N.createHash("sha256").update(r).digest("base64url");
+}
+f(D, "generateCodeChallenge");
+function _(r) {
+  const o = N.randomUUID(), n = B(), e = D(n);
+  C.set(o, {
+    codeVerifier: n,
+    nodeId: r.nodeId,
+    clientId: r.clientId,
+    loginUrl: r.loginUrl,
+    callbackUrl: r.callbackUrl,
+    timestamp: Date.now()
+  });
+  for (const [s, a] of C)
+    Date.now() - a.timestamp > z && C.delete(s);
+  return { state: o, codeChallenge: e };
+}
+f(_, "createAuthState");
+function tt(r) {
+  const o = C.get(r);
+  return !o || (C.delete(r), Date.now() - o.timestamp > z) ? null : o;
+}
+f(tt, "consumeAuthState");
+function et(r) {
+  return r.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+f(et, "escapeHtml");
+function k(r, o = !0) {
+  const n = o ? "<script>setTimeout(function(){window.close()},3000)</script>" : "";
+  return `<html><body><h2>Authorization Failed</h2><p>${et(r)}</p>${n}</body></html>`;
+}
+f(k, "errorPage");
+function nt(r) {
+  const o = (r.settings.httpAdminRoot || "").replace(
+    /\/$/,
+    ""
+  );
+  r.httpAdmin.post("/salesforce/auth/start", (n, e) => {
+    try {
+      const {
+        nodeId: s,
+        loginUrl: a,
+        clientId: l,
+        callbackUrl: d
+      } = n.body;
+      if (!s || !a || !l) {
+        e.status(400).json({ error: "nodeId, loginUrl, and clientId are required" });
+        return;
+      }
+      const c = d || `${n.protocol}://${n.get("host")}${o}/salesforce/auth/callback`, { state: g, codeChallenge: u } = _({
+        nodeId: s,
+        clientId: l,
+        loginUrl: a,
+        callbackUrl: c
+      }), p = new URLSearchParams({
+        response_type: "code",
+        client_id: l,
+        redirect_uri: c,
+        state: g,
+        code_challenge: u,
+        code_challenge_method: "S256"
+      });
+      e.json({
+        authorizationUrl: `${a}/services/oauth2/authorize?${p.toString()}`
+      });
+    } catch (s) {
+      r.log.error(
+        `salesforce-connection: auth/start error: ${s instanceof Error ? s.message : String(s)}`
+      ), e.status(500).json({ error: "Failed to start authorization" });
+    }
+  }), r.httpAdmin.get("/salesforce/auth/callback", async (n, e) => {
+    try {
+      const { code: s, state: a, error: l, error_description: d } = n.query;
+      if (l) {
+        r.log.error(
+          `salesforce-connection: OAuth error: ${l} - ${d}`
+        ), e.status(400).send(k(String(d || l)));
+        return;
+      }
+      if (!s || !a) {
+        e.status(400).send(k("Missing code or state parameter"));
+        return;
+      }
+      const c = tt(a);
+      if (!c) {
+        e.status(400).send(
+          k(
+            "Invalid or expired authorization state. Please try again."
+          )
+        );
+        return;
+      }
+      const g = await fetch(
+        `${c.loginUrl}/services/oauth2/token`,
+        {
+          method: "POST",
+          headers: { "Content-Type": "application/x-www-form-urlencoded" },
+          body: new URLSearchParams({
+            grant_type: "authorization_code",
+            code: s,
+            client_id: c.clientId,
+            redirect_uri: c.callbackUrl,
+            code_verifier: c.codeVerifier
+          })
+        }
+      );
+      if (!g.ok) {
+        const w = await g.text();
+        r.log.error(
+          `salesforce-connection: Token exchange failed: ${w}`
+        ), e.status(500).send(
+          k(
+            "Token exchange failed. Check the Node-RED logs for details."
+          )
+        );
+        return;
+      }
+      const u = await g.json();
+      r.nodes.addCredentials(c.nodeId, {
+        accessToken: u.access_token,
+        refreshToken: u.refresh_token,
+        instanceUrl: u.instance_url
+      }), r.log.info(
+        `salesforce-connection: Successfully authorized node ${c.nodeId} for ${u.instance_url}`
+      );
+      const p = JSON.stringify({
+        type: "salesforce-auth-success",
+        nodeId: c.nodeId,
+        accessToken: u.access_token,
+        refreshToken: u.refresh_token,
+        instanceUrl: u.instance_url
+      });
+      e.send(`<!DOCTYPE html>
+<html>
+<body>
+<h2>Authorization Successful</h2>
+<p>You can close this window.</p>
+<script>
+  if (window.opener) {
+    window.opener.postMessage(${p}, "*");
+  }
+  setTimeout(function() { window.close(); }, 1500);
+</script>
+</body>
+</html>`);
+    } catch (s) {
+      r.log.error(
+        `salesforce-connection: auth/callback error: ${s instanceof Error ? s.message : String(s)}`
+      ), e.status(500).send(k("An unexpected error occurred."));
+    }
+  }), r.httpAdmin.get("/salesforce/auth/status/:nodeId", (n, e) => {
+    try {
+      const s = r.nodes.getCredentials(n.params.nodeId), a = !!(s != null && s.accessToken && (s != null && s.instanceUrl));
+      e.json({
+        authenticated: a,
+        instanceUrl: a ? s.instanceUrl : void 0
+      });
+    } catch {
+      e.json({ authenticated: !1 });
+    }
+  });
+}
+f(nt, "initAuthRoutes");
+function ot(r) {
+  nt(r);
+}
+f(ot, "initRoutes");
+const L = class L extends G {
+  constructor() {
+    super(...arguments);
+    i(this, "conn", null);
+  }
+  static async registered(n) {
+    ot(n);
+  }
+  async getConnection() {
+    if (this.conn) return this.conn;
+    const n = this.credentials;
+    if (!(n != null && n.accessToken) || !(n != null && n.instanceUrl))
+      throw new Error(
+        "Salesforce connection not authorized. Please authorize in the node configuration."
+      );
+    return this.conn = new W.Connection({
+      oauth2: {
+        clientId: this.config.clientId,
+        loginUrl: this.config.loginUrl
+      },
+      instanceUrl: n.instanceUrl,
+      accessToken: n.accessToken,
+      refreshToken: n.refreshToken,
+      version: this.config.apiVersion
+    }), this.conn.on("refresh", (e) => {
+      this.RED.nodes.addCredentials(this.id, {
+        ...this.credentials,
+        accessToken: e
+      });
+    }), this.conn;
+  }
+  getAccessToken() {
+    var n;
+    return (n = this.credentials) == null ? void 0 : n.accessToken;
+  }
+  getInstanceUrl() {
+    var n;
+    return (n = this.credentials) == null ? void 0 : n.instanceUrl;
+  }
+  async closed() {
+    this.conn = null;
+  }
+};
+f(L, "SalesforceConnection"), i(L, "type", "salesforce-connection"), i(L, "configSchema", X), i(L, "credentialsSchema", Z);
+let $ = L;
+const it = h(
+  {
+    name: t.String({ default: "", "x-nrg-form": { icon: "tag" } }),
+    connection: t.NodeRef($, {
+      "x-nrg-form": { icon: "cloud" }
+    }),
+    query: t.TypedInput({
+      "x-nrg-form": {
+        icon: "search",
+        typedInputTypes: ["str", "msg", "flow", "global"]
+      }
+    })
+  },
+  { $id: "salesforce-soql:config" }
+), st = h(
+  {
+    payload: t.Any()
+  },
+  { $id: "salesforce-soql:input" }
+), rt = h(
+  {
+    payload: t.Array(t.Any()),
+    totalSize: t.Number(),
+    done: t.Boolean()
+  },
+  { $id: "salesforce-soql:output" }
+), m = class m extends F {
+  async input(o) {
+    const n = this.config.connection;
+    if (!n) {
+      this.error("No Salesforce connection configured", o);
+      return;
+    }
+    try {
+      this.status({ fill: "green", shape: "dot", text: "querying..." });
+      const e = await n.getConnection(), s = await this.config.query.resolve(o), a = await e.query(s);
+      this.status({
+        fill: "green",
+        shape: "dot",
+        text: `${a.totalSize} records`
+      }), this.send({
+        ...o,
+        payload: a.records,
+        totalSize: a.totalSize,
+        done: a.done
+      });
+    } catch (e) {
+      this.status({
+        fill: "red",
+        shape: "dot",
+        text: e instanceof Error ? e.message : String(e)
+      }), this.error(
+        `SOQL query failed: ${e instanceof Error ? e.message : String(e)}`,
+        o
+      );
+    }
+  }
+};
+f(m, "SalesforceSoql"), i(m, "type", "salesforce-soql"), i(m, "category", "salesforce"), i(m, "color", "#FFFFFF"), i(m, "inputs", 1), i(m, "outputs", 1), i(m, "configSchema", it), i(m, "inputSchema", st), i(m, "outputsSchema", rt);
+let O = m;
+const at = h(
+  {
+    name: t.String({ default: "", "x-nrg-form": { icon: "tag" } }),
+    connection: t.NodeRef($, {
+      "x-nrg-form": { icon: "cloud" }
+    }),
+    operation: t.Union(
+      [
+        t.Literal("create"),
+        t.Literal("read"),
+        t.Literal("update"),
+        t.Literal("delete"),
+        t.Literal("upsert")
+      ],
+      { default: "create", "x-nrg-form": { icon: "pencil" } }
+    ),
+    sObjectType: t.TypedInput({
+      "x-nrg-form": {
+        icon: "cube",
+        typedInputTypes: ["str", "msg"]
+      }
+    }),
+    record: t.TypedInput({
+      "x-nrg-form": {
+        icon: "file-code-o",
+        typedInputTypes: ["json", "msg"]
+      }
+    }),
+    externalIdField: t.Optional(
+      t.String({
+        default: "",
+        "x-nrg-form": { icon: "key" }
+      })
+    )
+  },
+  {
+    $id: "salesforce-dml:config",
+    if: t.Object({
+      operation: t.Literal("upsert")
+    }),
+    then: t.Object({
+      externalIdField: t.String({ minLength: 1 })
+    }),
+    errorMessage: {
+      properties: {
+        externalIdField: "External ID Field is required for upsert operations"
+      }
+    }
+  }
+), ct = h(
+  {
+    payload: t.Any()
+  },
+  { $id: "salesforce-dml:input" }
+), lt = h(
+  {
+    payload: t.Any()
+  },
+  { $id: "salesforce-dml:output" }
+), y = class y extends F {
+  async input(o) {
+    const n = this.config.connection;
+    if (!n) {
+      this.error("No Salesforce connection configured", o);
+      return;
+    }
+    try {
+      const e = this.config.operation;
+      this.status({ fill: "green", shape: "dot", text: `${e}...` });
+      const s = await n.getConnection(), a = await this.config.sObjectType.resolve(o), l = s.sobject(a), d = await this.config.record.resolve(o) ?? o.payload;
+      let c;
+      switch (e) {
+        case "create":
+          c = await l.create(d);
+          break;
+        case "read":
+          c = await l.retrieve(d);
+          break;
+        case "update":
+          c = await l.update(d);
+          break;
+        case "delete":
+          c = await l.destroy(d);
+          break;
+        case "upsert":
+          c = await l.upsert(d, this.config.externalIdField);
+          break;
+        default:
+          throw new Error(`Unknown operation: ${e}`);
+      }
+      this.status({ fill: "green", shape: "dot", text: `${e} done` }), this.send({ ...o, payload: c });
+    } catch (e) {
+      this.status({
+        fill: "red",
+        shape: "dot",
+        text: e instanceof Error ? e.message : String(e)
+      }), this.error(
+        `DML ${this.config.operation} failed: ${e instanceof Error ? e.message : String(e)}`,
+        o
+      );
+    }
+  }
+};
+f(y, "SalesforceDml"), i(y, "type", "salesforce-dml"), i(y, "category", "salesforce"), i(y, "color", "#FFFFFF"), i(y, "inputs", 1), i(y, "outputs", 1), i(y, "configSchema", at), i(y, "inputSchema", ct), i(y, "outputsSchema", lt);
+let R = y;
+const dt = h(
+  {
+    name: t.String({ default: "", "x-nrg-form": { icon: "tag" } }),
+    connection: t.NodeRef($, {
+      "x-nrg-form": { icon: "cloud" }
+    }),
+    operation: t.Union(
+      [
+        t.Literal("insert"),
+        t.Literal("update"),
+        t.Literal("upsert"),
+        t.Literal("delete"),
+        t.Literal("query")
+      ],
+      { default: "insert", "x-nrg-form": { icon: "database" } }
+    ),
+    sObjectType: t.TypedInput({
+      "x-nrg-form": {
+        icon: "cube",
+        typedInputTypes: ["str", "msg"]
+      }
+    }),
+    externalIdField: t.Optional(
+      t.String({
+        default: "",
+        "x-nrg-form": { icon: "key" }
+      })
+    ),
+    assignmentRuleId: t.Optional(
+      t.String({
+        default: "",
+        "x-nrg-form": { icon: "gavel" }
+      })
+    ),
+    columnDelimiter: t.Union(
+      [
+        t.Literal("COMMA"),
+        t.Literal("TAB"),
+        t.Literal("PIPE"),
+        t.Literal("SEMICOLON"),
+        t.Literal("CARET"),
+        t.Literal("BACKQUOTE")
+      ],
+      { default: "COMMA", "x-nrg-form": { icon: "columns" } }
+    ),
+    lineEnding: t.Union(
+      [t.Literal("LF"), t.Literal("CRLF")],
+      { default: "LF", "x-nrg-form": { icon: "level-down" } }
+    ),
+    pollInterval: t.Number({
+      default: 5e3,
+      minimum: 1e3,
+      "x-nrg-form": { icon: "clock-o" }
+    }),
+    pollTimeout: t.Number({
+      default: 6e4,
+      minimum: 5e3,
+      "x-nrg-form": { icon: "hourglass" }
+    }),
+    emitJobCreated: t.Boolean({
+      default: !1,
+      "x-nrg-form": { icon: "flag", toggle: !0 }
+    }),
+    outputs: t.Number({ default: 2 })
+  },
+  {
+    $id: "salesforce-bulk:config",
+    if: t.Object({
+      operation: t.Literal("upsert")
+    }),
+    then: t.Object({
+      externalIdField: t.String({ minLength: 1 })
+    }),
+    errorMessage: {
+      properties: {
+        externalIdField: "External ID Field is required for upsert operations"
+      }
+    }
+  }
+), ut = h(
+  {
+    payload: t.Any()
+  },
+  { $id: "salesforce-bulk:input" }
+);
+h(
+  {
+    payload: t.Array(t.Any())
+  },
+  { $id: "salesforce-bulk:output" }
+);
+const T = class T extends F {
+  sendRecord(o, n) {
+    const e = this.config.emitJobCreated ? 3 : 2, s = Array(e).fill(null);
+    s[0] = { ...o, payload: n }, this.send(s);
+  }
+  sendJobCreated(o, n) {
+    this.config.emitJobCreated && this.send([null, null, { ...o, payload: n }]);
+  }
+  sendComplete(o, n) {
+    const e = this.config.emitJobCreated ? 3 : 2, s = Array(e).fill(null);
+    s[1] = { ...o, payload: n }, this.send(s);
+  }
+  async input(o) {
+    const n = this.config.connection;
+    if (!n) {
+      this.error("No Salesforce connection configured", o);
+      return;
+    }
+    try {
+      const e = this.config.operation;
+      this.status({
+        fill: "green",
+        shape: "dot",
+        text: `bulk ${e}...`
+      });
+      const s = await n.getConnection(), a = await this.config.sObjectType.resolve(o);
+      let l = 0;
+      if (e === "query") {
+        const d = await s.bulk2.query(o.payload, {
+          pollTimeout: this.config.pollTimeout,
+          pollInterval: this.config.pollInterval,
+          columnDelimiter: this.config.columnDelimiter,
+          lineEnding: this.config.lineEnding
+        });
+        await new Promise((c, g) => {
+          d.on("data", (u) => {
+            l++, this.sendRecord(o, u);
+          }), d.on("end", () => c()), d.on("error", g);
+        }), this.status({
+          fill: "green",
+          shape: "dot",
+          text: `bulk ${e}: ${l} records`
+        }), this.sendComplete(o, { operation: e, sObjectType: a, totalRecords: l });
+      } else {
+        const d = o.payload, c = s.bulk2.createJob({
+          operation: e,
+          object: a,
+          columnDelimiter: this.config.columnDelimiter,
+          lineEnding: this.config.lineEnding,
+          ...e === "upsert" && this.config.externalIdField ? { externalIdFieldName: this.config.externalIdField } : {},
+          ...this.config.assignmentRuleId ? { assignmentRuleId: this.config.assignmentRuleId } : {}
+        });
+        await c.open(), this.sendJobCreated(o, {
+          jobId: c.id,
+          operation: e,
+          sObjectType: a,
+          state: "Open"
+        }), await c.uploadData(d), await c.close(), await c.poll(this.config.pollInterval, this.config.pollTimeout);
+        const g = await c.getAllResults(), u = g.successfulResults ?? [], p = g.failedResults ?? [], w = g.unprocessedRecords ?? [];
+        l = u.length + p.length + w.length;
+        for (const A of u)
+          this.sendRecord(o, A);
+        for (const A of p)
+          this.sendRecord(o, A);
+        const q = u.length, M = p.length;
+        this.status({
+          fill: M > 0 ? "red" : "green",
+          shape: "dot",
+          text: `bulk ${e}: ${l} records`
+        }), this.sendComplete(o, {
+          jobId: c.id,
+          operation: e,
+          sObjectType: a,
+          totalRecords: l,
+          successCount: q,
+          failureCount: M,
+          unprocessedCount: w.length
+        });
+      }
+    } catch (e) {
+      const s = e instanceof Error ? e.message : String(e);
+      this.status({ fill: "red", shape: "dot", text: s }), this.error(`Bulk ${this.config.operation} failed: ${s}`, o);
+    }
+  }
+};
+f(T, "SalesforceBulk"), i(T, "type", "salesforce-bulk"), i(T, "category", "salesforce"), i(T, "color", "#FFFFFF"), i(T, "inputs", 1), i(T, "outputs", 2), i(T, "configSchema", dt), i(T, "inputSchema", ut);
+let S = T;
+const ht = h(
+  {
+    name: t.String({ default: "", "x-nrg-form": { icon: "tag" } }),
+    connection: t.NodeRef($, {
+      "x-nrg-form": { icon: "cloud" }
+    }),
+    sObjectType: t.TypedInput({
+      "x-nrg-form": {
+        icon: "cube",
+        typedInputTypes: ["str", "msg"]
+      }
+    })
+  },
+  { $id: "salesforce-describe:config" }
+), pt = h(
+  {
+    payload: t.Any()
+  },
+  { $id: "salesforce-describe:input" }
+), ft = h(
+  {
+    payload: t.Object({
+      name: t.String(),
+      fields: t.Array(t.Any()),
+      childRelationships: t.Array(t.Any()),
+      recordTypeInfos: t.Array(t.Any())
+    })
+  },
+  { $id: "salesforce-describe:output" }
+), b = class b extends F {
+  async input(o) {
+    const n = this.config.connection;
+    if (!n) {
+      this.error("No Salesforce connection configured", o);
+      return;
+    }
+    try {
+      this.status({ fill: "green", shape: "dot", text: "describing..." });
+      const e = await n.getConnection(), s = await this.config.sObjectType.resolve(o), a = await e.sobject(s).describe();
+      this.status({
+        fill: "green",
+        shape: "dot",
+        text: `${a.name}: ${a.fields.length} fields`
+      }), this.send({
+        ...o,
+        payload: {
+          name: a.name,
+          fields: a.fields,
+          childRelationships: a.childRelationships,
+          recordTypeInfos: a.recordTypeInfos
+        }
+      });
+    } catch (e) {
+      this.status({
+        fill: "red",
+        shape: "dot",
+        text: e instanceof Error ? e.message : String(e)
+      }), this.error(
+        `Describe failed: ${e instanceof Error ? e.message : String(e)}`,
+        o
+      );
+    }
+  }
+};
+f(b, "SalesforceDescribe"), i(b, "type", "salesforce-describe"), i(b, "category", "salesforce"), i(b, "color", "#FFFFFF"), i(b, "inputs", 1), i(b, "outputs", 1), i(b, "configSchema", ht), i(b, "inputSchema", pt), i(b, "outputsSchema", ft);
+let E = b;
+const gt = h(
+  {
+    name: t.String({ default: "", "x-nrg-form": { icon: "tag" } }),
+    connection: t.NodeRef($, {
+      "x-nrg-form": { icon: "cloud" }
+    }),
+    channelName: t.String({
+      default: "",
+      "x-nrg-form": { icon: "rss" }
+    }),
+    subscribeType: t.Union(
+      [
+        t.Literal("LATEST"),
+        t.Literal("EARLIEST"),
+        t.Literal("CUSTOM")
+      ],
+      { default: "LATEST", "x-nrg-form": { icon: "history" } }
+    ),
+    replayId: t.Optional(
+      t.String({
+        default: "",
+        "x-nrg-form": { icon: "bookmark" }
+      })
+    ),
+    numRequested: t.Number({
+      default: 100,
+      minimum: 1,
+      maximum: 100,
+      "x-nrg-form": { icon: "sort-numeric-asc" }
+    })
+  },
+  {
+    $id: "salesforce-streaming:config",
+    if: t.Object({
+      subscribeType: t.Literal("CUSTOM")
+    }),
+    then: t.Object({
+      replayId: t.String({ minLength: 1 })
+    }),
+    errorMessage: {
+      properties: {
+        replayId: "Replay ID is required when Subscribe Type is CUSTOM"
+      }
+    }
+  }
+), mt = h(
+  {
+    payload: t.Any(),
+    replayId: t.Any(),
+    channel: t.String(),
+    topic: t.String()
+  },
+  { $id: "salesforce-streaming:output" }
+), I = class I extends F {
+  constructor() {
+    super(...arguments);
+    i(this, "client", null);
+    i(this, "reconnectAttempt", 0);
+    i(this, "maxReconnectDelay", 6e4);
+  }
+  async created() {
+    const n = this.config.connection;
+    if (!n) {
+      this.status({ fill: "red", shape: "dot", text: "no connection" }), this.error("No Salesforce connection configured");
+      return;
+    }
+    await this.subscribe(n);
+  }
+  async subscribe(n) {
+    try {
+      this.status({ fill: "green", shape: "dot", text: "connecting..." });
+      const e = n.getAccessToken(), s = n.getInstanceUrl();
+      if (!e || !s) {
+        this.status({ fill: "red", shape: "dot", text: "not authorized" }), this.error("Salesforce connection not authorized");
+        return;
+      }
+      const a = (await import("salesforce-pubsub-api-client")).default;
+      this.client = new a({
+        authType: "user-supplied",
+        accessToken: e,
+        instanceUrl: s
+      }), await this.client.connect();
+      const l = this.config.numRequested || null, d = this.config.channelName, c = /* @__PURE__ */ f((g, u, p) => {
+        if (u === "event" || u === "lastevent")
+          this.send({
+            payload: (p == null ? void 0 : p.payload) ?? p,
+            replayId: p == null ? void 0 : p.replayId,
+            channel: d,
+            topic: d
+          });
+        else if (u === "error") {
+          const w = p instanceof Error ? p.message : String(p ?? "stream error");
+          this.warn(`Streaming error: ${w}`), this.status({ fill: "red", shape: "dot", text: w }), this.scheduleReconnect(n);
+        } else u === "end" && (this.log("Streaming subscription ended"), this.status({ fill: "red", shape: "dot", text: "disconnected" }), this.scheduleReconnect(n));
+      }, "callback");
+      if (this.config.subscribeType === "EARLIEST")
+        this.client.subscribeFromEarliestEvent(
+          d,
+          c,
+          l
+        );
+      else if (this.config.subscribeType === "CUSTOM" && this.config.replayId) {
+        const g = parseInt(this.config.replayId, 10);
+        this.client.subscribeFromReplayId(
+          d,
+          c,
+          l,
+          g
+        );
+      } else
+        this.client.subscribe(d, c, l);
+      this.status({
+        fill: "green",
+        shape: "dot",
+        text: `subscribed: ${d}`
+      }), this.reconnectAttempt = 0;
+    } catch (e) {
+      this.status({
+        fill: "red",
+        shape: "dot",
+        text: e instanceof Error ? e.message : String(e)
+      }), this.error(
+        `Streaming subscription failed: ${e instanceof Error ? e.message : String(e)}`
+      ), this.scheduleReconnect(n);
+    }
+  }
+  scheduleReconnect(n) {
+    this.reconnectAttempt++;
+    const e = Math.min(
+      1e3 * Math.pow(2, this.reconnectAttempt),
+      this.maxReconnectDelay
+    );
+    this.log(
+      `Scheduling reconnect in ${e}ms (attempt ${this.reconnectAttempt})`
+    ), this.status({
+      fill: "green",
+      shape: "dot",
+      text: `reconnecting in ${Math.round(e / 1e3)}s`
+    }), this.setTimeout(async () => {
+      await this.cleanup(), await this.subscribe(n);
+    }, e);
+  }
+  async cleanup() {
+    var n, e;
+    try {
+      this.client && (await ((e = (n = this.client).close) == null ? void 0 : e.call(n)), this.client = null);
+    } catch {
+    }
+  }
+  async input() {
+  }
+  async closed() {
+    await this.cleanup();
+  }
+};
+f(I, "SalesforceStreaming"), i(I, "type", "salesforce-streaming"), i(I, "category", "salesforce"), i(I, "color", "#FFFFFF"), i(I, "inputs", 0), i(I, "outputs", 1), i(I, "configSchema", gt), i(I, "outputsSchema", mt);
+let j = I;
+const yt = h(
+  {
+    name: t.String({ default: "", "x-nrg-form": { icon: "tag" } }),
+    connection: t.NodeRef($, {
+      "x-nrg-form": { icon: "cloud" }
+    }),
+    method: t.Union(
+      [
+        t.Literal("GET"),
+        t.Literal("POST"),
+        t.Literal("PUT"),
+        t.Literal("PATCH"),
+        t.Literal("DELETE")
+      ],
+      { default: "POST", "x-nrg-form": { icon: "random" } }
+    ),
+    path: t.TypedInput({
+      "x-nrg-form": {
+        icon: "link",
+        typedInputTypes: ["str", "msg"]
+      }
+    })
+  },
+  { $id: "salesforce-apex:config" }
+), bt = h(
+  {
+    payload: t.Any()
+  },
+  { $id: "salesforce-apex:input" }
+), xt = h(
+  {
+    payload: t.Any()
+  },
+  { $id: "salesforce-apex:output" }
+), x = class x extends F {
+  async input(o) {
+    const n = this.config.connection;
+    if (!n) {
+      this.error("No Salesforce connection configured", o);
+      return;
+    }
+    try {
+      const e = this.config.method;
+      this.status({ fill: "green", shape: "dot", text: `${e}...` });
+      const s = await n.getConnection(), a = await this.config.path.resolve(o);
+      let l;
+      const d = e.toLowerCase();
+      d === "get" || d === "delete" ? l = await s.apex[d](a) : l = await s.apex[d](a, o.payload), this.status({ fill: "green", shape: "dot", text: `${e} done` }), this.send({ ...o, payload: l });
+    } catch (e) {
+      this.status({
+        fill: "red",
+        shape: "dot",
+        text: e instanceof Error ? e.message : String(e)
+      }), this.error(
+        `Apex ${this.config.method} failed: ${e instanceof Error ? e.message : String(e)}`,
+        o
+      );
+    }
+  }
+};
+f(x, "SalesforceApex"), i(x, "type", "salesforce-apex"), i(x, "category", "salesforce"), i(x, "color", "#FFFFFF"), i(x, "inputs", 1), i(x, "outputs", 1), i(x, "configSchema", yt), i(x, "inputSchema", bt), i(x, "outputsSchema", xt);
+let v = x;
+const Tt = K({
+  nodes: [
+    $,
+    O,
+    R,
+    S,
+    E,
+    j,
+    v
+  ]
+});
+var U = Tt;
+U && typeof U == "object" && Array.isArray(U.nodes) && (U = Y(U.nodes));
+export {
+  U as default
+};
+//# sourceMappingURL=index.mjs.map