@sourceregistry/node-ovsdb 1.0.2 → 1.0.3

package/dist/index.es

@@ -0,0 +1,613 @@
+import { existsSync as f } from "node:fs";
+import { createConnection as l } from "node:net";
+import { EventEmitter as w } from "node:events";
+import { connect as g } from "node:tls";
+class E extends Error {
+  /**
+   * The error payload returned by the server.
+   */
+  response;
+  /**
+   * Creates a new RPC error wrapper.
+   */
+  constructor(t) {
+    super(t.details ? `${t.error}: ${t.details}` : t.error), this.name = "OvsdbRpcError", this.response = t;
+  }
+}
+class m extends Error {
+  /**
+   * The raw payload that failed validation.
+   */
+  payload;
+  /**
+   * Creates a new protocol error wrapper.
+   */
+  constructor(t, e) {
+    super(t), this.name = "OvsdbProtocolError", this.payload = e;
+  }
+}
+class y extends Error {
+  /**
+   * Zero-based index of the failed operation in the submitted transaction.
+   */
+  operationIndex;
+  /**
+   * Operation that produced the error.
+   */
+  operation;
+  /**
+   * OVSDB error payload returned for the failed operation.
+   */
+  result;
+  /**
+   * Raw transaction results returned by the server.
+   */
+  results;
+  /**
+   * Creates a new transaction error wrapper.
+   */
+  constructor(t) {
+    super(`Transaction operation ${t.operationIndex} failed: ${t.result.error}`), this.name = "OvsdbTransactionError", this.operationIndex = t.operationIndex, this.operation = t.operation, this.result = t.result, this.results = t.results;
+  }
+}
+class k {
+  stagedOperations = [];
+  /**
+   * Returns the currently staged operations.
+   */
+  get operations() {
+    return this.stagedOperations;
+  }
+  /**
+   * Adds an operation to the transaction.
+   */
+  add(t) {
+    return this.stagedOperations.push(t), t;
+  }
+  /**
+   * Stages an insert operation.
+   */
+  insert(t) {
+    return this.add(t);
+  }
+  /**
+   * Stages a select operation.
+   */
+  select(t) {
+    return this.add(t);
+  }
+  /**
+   * Stages an update operation.
+   */
+  update(t) {
+    return this.add(t);
+  }
+  /**
+   * Stages a mutate operation.
+   */
+  mutate(t) {
+    return this.add(t);
+  }
+  /**
+   * Stages a delete operation.
+   */
+  delete(t) {
+    return this.add(t);
+  }
+  /**
+   * Stages a wait operation.
+   */
+  wait(t) {
+    return this.add(t);
+  }
+  /**
+   * Stages a comment operation.
+   */
+  comment(t) {
+    return this.add({
+      op: "comment",
+      comment: t
+    });
+  }
+  /**
+   * Stages an assert operation.
+   */
+  assert(t) {
+    return this.add({
+      op: "assert",
+      lock: t
+    });
+  }
+  /**
+   * Stages a commit operation.
+   */
+  commit(t = !1) {
+    return this.add({
+      op: "commit",
+      durable: t
+    });
+  }
+  /**
+   * Stages an abort operation.
+   */
+  abort() {
+    return this.add({
+      op: "abort"
+    });
+  }
+}
+class x extends w {
+  timeout;
+  connectionOptions;
+  connectionFactory;
+  socket = null;
+  requestId = 1;
+  receiveBuffer = "";
+  pendingRequests = /* @__PURE__ */ new Map();
+  connected = !1;
+  closeEmitted = !1;
+  /**
+   * Creates a new OVSDB client instance.
+   */
+  constructor(t = {}) {
+    super(), this.timeout = t.timeout ?? 5e3, this.connectionOptions = q(t), this.connectionFactory = t.connectionFactory;
+  }
+  /**
+   * Returns `true` when the underlying socket is currently connected.
+   */
+  get isConnected() {
+    return this.connected;
+  }
+  /**
+   * Opens the transport connection.
+   *
+   * @returns The connected client instance for chaining.
+   */
+  async connect() {
+    if (this.connected)
+      return this;
+    if (!this.connectionFactory && this.connectionOptions.transport === "unix" && !f(this.connectionOptions.socketPath))
+      throw new Error(`OVSDB socket not found: ${this.connectionOptions.socketPath}`);
+    const t = this.connectionFactory ? this.connectionFactory(this.connectionOptions) : v(this.connectionOptions);
+    this.attachSocket(t);
+    const e = this.connectionOptions.transport === "tls" ? "secureConnect" : "connect";
+    return await new Promise((s, n) => {
+      const a = setTimeout(() => {
+        i(), this.disposeTransport(new Error(`Connection timeout after ${this.timeout}ms`)), n(new Error(`Connection timeout after ${this.timeout}ms`));
+      }, this.timeout), o = () => {
+        i(), this.connected = !0, this.closeEmitted = !1, this.emit("connect"), s();
+      }, c = (h) => {
+        i(), n(h);
+      }, i = () => {
+        clearTimeout(a), t.off(e, o), t.off("error", c);
+      };
+      t.once(e, o), t.once("error", c);
+    }), this;
+  }
+  /**
+   * Sends a raw JSON-RPC request and resolves with its `result` payload.
+   *
+   * @param method RPC method name.
+   * @param params RPC parameters.
+   */
+  async request(t, e = []) {
+    this.assertConnected();
+    const s = this.requestId++, n = {
+      method: t,
+      params: e,
+      id: s
+    };
+    return await new Promise((a, o) => {
+      const c = setTimeout(() => {
+        this.pendingRequests.delete(s), o(new Error(`Request timeout for method: ${t}`));
+      }, this.timeout);
+      this.pendingRequests.set(s, {
+        resolve: (i) => a(i),
+        reject: o,
+        timeoutId: c
+      }), this.writeMessage(n).catch((i) => {
+        clearTimeout(c), this.pendingRequests.delete(s), o(i);
+      });
+    });
+  }
+  /**
+   * Sends a JSON-RPC notification without waiting for a response.
+   *
+   * @param method RPC method name.
+   * @param params RPC parameters.
+   */
+  async notify(t, e = []) {
+    this.assertConnected(), await this.writeMessage({ method: t, params: e });
+  }
+  /**
+   * Returns the database names exposed by the connected OVSDB server.
+   */
+  async listDbs() {
+    return await this.request("list_dbs", []);
+  }
+  /**
+   * Returns the schema definition for a database.
+   *
+   * @param dbName Database name.
+   */
+  async getSchema(t = "Open_vSwitch") {
+    return await this.request("get_schema", [t]);
+  }
+  /**
+   * Executes a single transaction.
+   *
+   * The response preserves operation ordering, so tuple inputs infer tuple outputs.
+   *
+   * @param dbName Database name.
+   * @param operations Transaction operations.
+   */
+  async transact(t, e) {
+    return await this.request(
+      "transact",
+      [t, ...e]
+    );
+  }
+  /**
+   * Stages a transaction in a callback and submits it only if the callback
+   * completes successfully.
+   *
+   * This helper is convenient when you want a scoped, imperative API while
+   * still sending exactly one OVSDB `transact` request.
+   *
+   * @param dbName Database name.
+   * @param callback Callback that stages operations on the transaction object.
+   * @param options Auto-commit behavior for the staged transaction.
+   */
+  async transaction(t, e, s = {}) {
+    const n = new k(), a = await e(n), o = [...n.operations], c = s.autoCommit ?? !0, i = o.some((u) => u.op === "commit" || u.op === "abort");
+    if (c && !i && o.push({
+      op: "commit",
+      durable: s.durable ?? !1
+    }), o.length === 0)
+      return {
+        value: a,
+        operations: o,
+        results: []
+      };
+    const h = await this.request(
+      "transact",
+      [t, ...o]
+    );
+    for (const [u, d] of h.entries())
+      if (O(d))
+        throw new y({
+          operationIndex: u,
+          operation: o[u],
+          result: d,
+          results: h
+        });
+    return {
+      value: a,
+      operations: o,
+      results: h
+    };
+  }
+  /**
+   * Cancels a previously issued request by id.
+   *
+   * @param requestId JSON-RPC request id to cancel.
+   */
+  async cancel(t) {
+    return await this.request("cancel", [t]);
+  }
+  /**
+   * Starts a standard RFC 7047 monitor.
+   *
+   * @param dbName Database name.
+   * @param monitorId Application-defined monitor id.
+   * @param monitorRequests Per-table monitor definitions.
+   */
+  async monitor(t, e, s) {
+    return await this.request("monitor", [
+      t,
+      e,
+      s
+    ]);
+  }
+  /**
+   * Starts an Open vSwitch conditional monitor.
+   *
+   * @param dbName Database name.
+   * @param monitorId Application-defined monitor id.
+   * @param monitorRequests Per-table conditional monitor definitions.
+   */
+  async monitorCond(t, e, s) {
+    return await this.request("monitor_cond", [
+      t,
+      e,
+      s
+    ]);
+  }
+  /**
+   * Starts an Open vSwitch conditional monitor from a known transaction id.
+   *
+   * @param dbName Database name.
+   * @param monitorId Application-defined monitor id.
+   * @param monitorRequests Per-table conditional monitor definitions.
+   * @param lastTransactionId Last seen transaction id, or `null` for a fresh snapshot.
+   */
+  async monitorCondSince(t, e, s, n = null) {
+    return await this.request("monitor_cond_since", [
+      t,
+      e,
+      s,
+      n
+    ]);
+  }
+  /**
+   * Cancels a monitor by its monitor id.
+   *
+   * @param monitorId Monitor id used when the monitor was created.
+   */
+  async monitorCancel(t) {
+    return await this.request("monitor_cancel", [t]);
+  }
+  /**
+   * Acquires a named database lock.
+   *
+   * @param lockId Lock identifier.
+   */
+  async lock(t) {
+    return await this.request("lock", [t]);
+  }
+  /**
+   * Forces ownership of a named database lock.
+   *
+   * @param lockId Lock identifier.
+   */
+  async steal(t) {
+    return await this.request("steal", [t]);
+  }
+  /**
+   * Releases a previously acquired named database lock.
+   *
+   * @param lockId Lock identifier.
+   */
+  async unlock(t) {
+    return await this.request("unlock", [t]);
+  }
+  /**
+   * Sends an echo request to validate transport liveness.
+   *
+   * @param payload Values to be echoed back by the server.
+   */
+  async echo(...t) {
+    return await this.request("echo", t);
+  }
+  /**
+   * Enables or disables Open vSwitch database change awareness.
+   *
+   * @param enabled Whether the server should report change awareness metadata.
+   */
+  async setDbChangeAware(t = !0) {
+    return await this.request("set_db_change_aware", [t]);
+  }
+  /**
+   * Closes the connection and rejects all pending requests.
+   */
+  async close() {
+    this.disposeTransport();
+  }
+  /**
+   * Implements `AsyncDisposable`.
+   */
+  async [Symbol.asyncDispose]() {
+    await this.close();
+  }
+  attachSocket(t) {
+    this.socket = t, this.receiveBuffer = "", t.on("data", this.handleData), t.on("error", this.handleSocketError), t.on("close", this.handleSocketClose);
+  }
+  handleData = (t) => {
+    this.receiveBuffer += typeof t == "string" ? t : t.toString("utf8");
+    let e = p(this.receiveBuffer);
+    for (; e; )
+      this.receiveBuffer = e.rest, this.parseFrame(e.frame), e = p(this.receiveBuffer);
+    const s = this.receiveBuffer.trimStart();
+    s && s[0] !== "{" && s[0] !== "[" && (this.emitProtocolError("Received non-JSON data on the transport", this.receiveBuffer), this.receiveBuffer = "");
+  };
+  handleSocketError = (t) => {
+    this.emit("transportError", t), this.disposeTransport(t);
+  };
+  handleSocketClose = () => {
+    this.disposeTransport();
+  };
+  parseFrame(t) {
+    try {
+      const e = JSON.parse(t);
+      this.handleMessage(e);
+    } catch {
+      const s = new m("Failed to parse JSON message", t);
+      this.emit("protocolError", s, t);
+    }
+  }
+  handleMessage(t) {
+    if (!t || typeof t != "object") {
+      this.emitProtocolError("Expected a JSON object message", t);
+      return;
+    }
+    if ("method" in t && typeof t.method == "string") {
+      const e = t;
+      if (e.id !== void 0 && e.id !== null) {
+        this.handleIncomingRequest(e.method, e.params ?? [], e.id);
+        return;
+      }
+      this.handleNotification(t);
+      return;
+    }
+    if ("id" in t) {
+      this.handleResponse(t);
+      return;
+    }
+    this.emitProtocolError("Received message without method or id", t);
+  }
+  handleResponse(t) {
+    const e = this.pendingRequests.get(t.id);
+    if (!e) {
+      this.emitProtocolError("Received response for an unknown request id", t);
+      return;
+    }
+    if (this.pendingRequests.delete(t.id), clearTimeout(e.timeoutId), t.error) {
+      e.reject(new E(t.error));
+      return;
+    }
+    e.resolve(t.result);
+  }
+  async handleIncomingRequest(t, e, s) {
+    if (t === "echo") {
+      await this.writeMessage({
+        id: s,
+        result: e,
+        error: null
+      });
+      return;
+    }
+    await this.writeMessage({
+      id: s,
+      result: null,
+      error: {
+        error: "not supported",
+        details: `Unsupported server request: ${t}`
+      }
+    });
+  }
+  handleNotification(t) {
+    switch (this.emit("notification", t), t.method) {
+      case "update":
+        this.emit("update", t);
+        break;
+      case "update2":
+        this.emit("update2", t);
+        break;
+      case "update3":
+        this.emit("update3", t);
+        break;
+      case "locked":
+        this.emit("locked", t);
+        break;
+      case "stolen":
+        this.emit("stolen", t);
+        break;
+      default:
+        this.emitProtocolError("Received an unknown notification method", t);
+        break;
+    }
+  }
+  emitProtocolError(t, e) {
+    const s = new m(t, e);
+    this.emit("protocolError", s, e);
+  }
+  async writeMessage(t) {
+    this.assertConnected(), await new Promise((e, s) => {
+      this.socket?.write(`${JSON.stringify(t)}
+`, (n) => {
+        if (n) {
+          s(n);
+          return;
+        }
+        e();
+      });
+    });
+  }
+  assertConnected() {
+    if (!this.connected || !this.socket)
+      throw new Error("Not connected to OVSDB");
+  }
+  disposeTransport(t) {
+    const e = this.socket;
+    this.socket = null, this.connected = !1, this.receiveBuffer = "", e && (e.off("data", this.handleData), e.off("error", this.handleSocketError), e.off("close", this.handleSocketClose), e.destroyed || e.destroy());
+    const s = t ?? new Error("Connection closed");
+    for (const n of this.pendingRequests.values())
+      clearTimeout(n.timeoutId), n.reject(s);
+    this.pendingRequests.clear(), this.closeEmitted || (this.closeEmitted = !0, this.emit("close"));
+  }
+}
+function q(r = {}) {
+  if (r.host) {
+    const t = r.port ?? 6640;
+    return r.tls ? {
+      transport: "tls",
+      host: r.host,
+      port: t,
+      tlsOptions: {
+        host: r.host,
+        port: t,
+        ...r.tlsOptions
+      }
+    } : {
+      transport: "tcp",
+      host: r.host,
+      port: t
+    };
+  }
+  return {
+    transport: "unix",
+    socketPath: r.socketPath ?? "/var/run/openvswitch/db.sock"
+  };
+}
+function v(r) {
+  switch (r.transport) {
+    case "unix":
+      return l(r.socketPath);
+    case "tcp":
+      return l(r.port, r.host);
+    case "tls":
+      return g(r.tlsOptions);
+  }
+}
+function O(r) {
+  return typeof r == "object" && r !== null && "error" in r && typeof r.error == "string";
+}
+function p(r) {
+  let t = 0;
+  for (; t < r.length && /\s/u.test(r[t]); )
+    t += 1;
+  if (t >= r.length)
+    return null;
+  const e = r[t];
+  if (!(e === "{" ? "}" : e === "[" ? "]" : null))
+    return null;
+  let n = 0, a = !1, o = !1;
+  for (let c = t; c < r.length; c += 1) {
+    const i = r[c];
+    if (a) {
+      if (o) {
+        o = !1;
+        continue;
+      }
+      if (i === "\\") {
+        o = !0;
+        continue;
+      }
+      i === '"' && (a = !1);
+      continue;
+    }
+    if (i === '"') {
+      a = !0;
+      continue;
+    }
+    if (i === "{" || i === "[") {
+      n += 1;
+      continue;
+    }
+    if ((i === "}" || i === "]") && (n -= 1, n === 0))
+      return {
+        frame: r.slice(t, c + 1),
+        rest: r.slice(c + 1)
+      };
+  }
+  return null;
+}
+export {
+  x as OVSDBClient,
+  m as OvsdbProtocolError,
+  E as OvsdbRpcError,
+  k as OvsdbTransaction,
+  y as OvsdbTransactionError,
+  q as resolveConnectionOptions
+};
+//# sourceMappingURL=index.es.map