@sourceregistry/node-ovsdb 1.0.2 → 1.0.3

package/README.md

@@ -1,124 +1,330 @@
 # @sourceregistry/node-ovsdb
 
 [![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
+[![npm version](https://img.shields.io/npm/v/%40sourceregistry%2Fnode-ovsdb)](https://www.npmjs.com/package/@sourceregistry/node-ovsdb)
+[![codecov](https://codecov.io/gh/SourceRegistry/node-ovsdb/graph/badge.svg)](https://codecov.io/gh/SourceRegistry/node-ovsdb)
 [![Release to NPM](https://github.com/SourceRegistry/node-ovsdb/actions/workflows/publish-npm.yml/badge.svg)](https://github.com/SourceRegistry/node-ovsdb/actions/workflows/publish-npm.yml)
 
-A lightweight, typesafe TypeScript client for the Open vSwitch Database (OVSDB) Management Protocol, as defined in [RFC 7047](https://datatracker.ietf.org/doc/html/rfc7047).
+Low-level OVSDB client for Node.js with:
 
-This library provides a low-level wrapper to interact with the OVSDB over a Unix socket, enabling programmatic configuration and management of Open vSwitch instances.
+- Unix socket, TCP, and TLS transports
+- RFC 7047 core RPC support
+- Open vSwitch monitor extensions
+- typed transaction and monitor payloads
+- event-driven notifications
+- schema-to-TypeScript generation CLI
+- TSDoc-ready public API for Typedoc
 
 ## Installation
 
-Install the package using npm:
-
 ```bash
 npm install @sourceregistry/node-ovsdb
 ```
 
-## Usage
+Generate types from a schema with:
 
-### Getting Started
+```bash
+npx ovsdb-generate --help
+```
 
-The primary class is `OVSDBClient`, which handles the connection to the OVSDB server (typically located at `/var/run/openvswitch/db.sock`).
+## What It Supports
 
-```typescript
-import { OVSDBClient } from '@sourceregistry/node-ovsdb';
+The client is intentionally low-level and maps closely to the wire protocol.
 
-async function main() {
-  // Create a new client instance
-  const client = new OVSDBClient();
+- `list_dbs`
+- `get_schema`
+- `transact`
+- `cancel`
+- `monitor`
+- `monitor_cond`
+- `monitor_cond_since`
+- `monitor_cancel`
+- `lock`
+- `steal`
+- `unlock`
+- `echo`
+- `set_db_change_aware`
+- notifications: `update`, `update2`, `update3`, `locked`, `stolen`
 
-  try {
-    // Connect to the OVSDB Unix socket
-    await client.connect();
-    console.log('Connected to OVSDB');
+## Quick Start
 
-    // Example: Get the list of available databases
-    const databases = await client.listDbs();
-    console.log('Databases:', databases);
+Unix socket:
 
-    // Example: Get the schema of the 'Open_vSwitch' database
-    const schema = await client.getSchema('Open_vSwitch');
-    console.log('OVS Version:', schema.version);
+```ts
+import {OVSDBClient} from "@sourceregistry/node-ovsdb";
 
-    // Example: Perform a transaction to select all bridges
-    const operations = [
-      {
-        op: 'select',
-        table: 'Bridge',
-        where: [],
-        columns: ['name']
-      }
-    ];
+const client = new OVSDBClient({
+  socketPath: "/var/run/openvswitch/db.sock",
+  timeout: 5000
+});
 
-    const result = await client.transact('Open_vSwitch', operations);
-    console.log('Bridges:', result);
+try {
+  await client.connect();
 
-  } catch (error) {
-    console.error('An error occurred:', error.message);
-  } finally {
-    // Always close the connection
-    client.close();
-  }
+  const databases = await client.listDbs();
+  const schema = await client.getSchema("Open_vSwitch");
+
+  console.log(databases, schema.version);
+} finally {
+  await client.close();
 }
+```
+
+Plain TCP:
 
-main();
+```ts
+import {OVSDBClient} from "@sourceregistry/node-ovsdb";
+
+const client = new OVSDBClient({
+  host: "127.0.0.1",
+  port: 6640
+});
 ```
 
-### Using Async Disposable (Recommended)
+TLS:
 
-For guaranteed resource cleanup, use the client with the `using` statement (requires Node.js 18+ or the `--harmony-explicit-resource-management` flag):
+```ts
+import {OVSDBClient} from "@sourceregistry/node-ovsdb";
 
-```typescript
-import { OVSDBClient } from '@sourceregistry/node-ovsdb';
+const client = new OVSDBClient({
+  host: "ovsdb.example.internal",
+  port: 6640,
+  tls: true,
+  tlsOptions: {
+    servername: "ovsdb.example.internal",
+    rejectUnauthorized: true
+  }
+});
+```
 
-async function main() {
-  // The 'using' statement ensures the client is closed even if an error occurs
-  using client = new OVSDBClient();
+## Schema Generation
 
-  await client.connect();
-  console.log('Connected to OVSDB');
+The package includes an `ovsdb-generate` CLI that emits TypeScript row and database model types you can use with `OVSDBClient<...>`.
 
-  const dbs = await client.listDbs();
-  console.log('Available databases:', dbs);
-}
+Generate from a checked-in schema file:
 
-main();
+```bash
+npx ovsdb-generate --schema ./Open_vSwitch.schema.json --out ./src/generated/ovsdb.ts
 ```
 
-### Core Methods
+Generate directly from a live OVSDB server:
 
-The `OVSDBClient` class provides direct access to the core OVSDB RPC methods:
+```bash
+npx ovsdb-generate --socket /var/run/openvswitch/db.sock --db Open_vSwitch --out ./src/generated/ovsdb.ts
+```
 
-- `connect()`: Establishes a connection to the Unix socket.
-- `listDbs()`: Retrieves the names of available databases.
-- `getSchema(dbName)`: Retrieves the schema for a specific database.
-- `transact(dbName, operations)`: Executes a series of database operations atomically.
-- `monitor(...)`: Subscribes to database change notifications.
-- `echo()`: Tests the connection liveness.
-- `close()`: Closes the connection.
+Generate from a live TCP endpoint:
 
-### Advanced: Entity Wrappers (Coming Soon)
+```bash
+npx ovsdb-generate --host 127.0.0.1 --port 6640 --db Open_vSwitch --out ./src/generated/ovsdb.ts
+```
 
-For higher-level operations (e.g., `createBridge`, `addPort`), consider building wrapper classes on top of `OVSDBClient`. A future version of this library may include these.
+Generate from a live TLS endpoint:
 
-## Development
+```bash
+npx ovsdb-generate \
+  --host ovsdb.example.internal \
+  --port 6640 \
+  --tls \
+  --tls-ca-file ./pki/ca.pem \
+  --tls-cert-file ./pki/client.pem \
+  --tls-key-file ./pki/client.key \
+  --db Open_vSwitch \
+  --out ./src/generated/ovsdb.ts
+```
+
+You can override the generated top-level type name with `--name OpenVSwitchDb`.
+
+## Typed Transactions
+
+You can provide your own table model to get typed table names, rows, selected columns, conditions, mutations, and tuple-shaped transaction results.
+
+```ts
+import {OVSDBClient, type DatabaseOperation, type OvsSet} from "@sourceregistry/node-ovsdb";
+
+type OpenVSwitchDb = {
+  Bridge: {
+    name: string;
+    ports: OvsSet<string>;
+  };
+  Port: {
+    name: string;
+    interfaces: OvsSet<string>;
+  };
+};
+
+const client = new OVSDBClient<OpenVSwitchDb>();
+await client.connect();
+
+const operations = [
+  {
+    op: "select",
+    table: "Bridge",
+    where: [["name", "==", "br-int"]],
+    columns: ["name", "ports"]
+  },
+  {
+    op: "insert",
+    table: "Port",
+    row: {
+      name: "uplink0",
+      interfaces: ["set", []]
+    }
+  }
+] satisfies [DatabaseOperation<OpenVSwitchDb>, DatabaseOperation<OpenVSwitchDb>];
+
+const [bridges, insertedPort] = await client.transact("Open_vSwitch", operations);
+```
+
+For a higher-level staged flow, use `client.transaction(...)`. The callback can build operations against a transaction-scoped helper, and the library will send one `transact` request only if the callback completes successfully. By default it appends a trailing `commit` operation automatically.
+
+```ts
+const outcome = await client.transaction("Open_vSwitch", (tx) => {
+  tx.comment("prepare bridge lookup");
+  tx.select({
+    op: "select",
+    table: "Bridge",
+    where: [["name", "==", "br-int"]],
+    columns: ["name"]
+  });
+
+  return "ok";
+});
+```
+
+## Monitoring
+
+```ts
+import {OVSDBClient} from "@sourceregistry/node-ovsdb";
+
+const client = new OVSDBClient();
+await client.connect();
+
+client.on("update", (notification) => {
+  const [monitorId, updates] = notification.params;
+  console.log("monitor", monitorId, updates);
+});
+
+await client.monitor("Open_vSwitch", "bridges", {
+  Bridge: {
+    columns: ["name"],
+    select: {
+      initial: true,
+      insert: true,
+      modify: true,
+      delete: true
+    }
+  }
+});
+```
+
+For conditional monitoring, use `monitorCond()` or `monitorCondSince()`.
+
+### Detect When an Interface Is Attached to a Bridge
 
-### Prerequisites
+OVSDB does not usually emit a single semantic event like "interface attached to bridge". Instead, you observe the row changes that together mean an attachment happened:
 
-- Node.js (v18 or higher recommended)
+- a new `Interface` row may appear
+- a new `Port` row may appear
+- an existing `Bridge` row may be modified so its `ports` set now includes that port
 
-### Scripts
+In practice, the bridge update is usually the strongest signal that something was attached to the virtual switch.
 
-- `npm run dev`: Start the development server.
-- `npm run build`: Compile the TypeScript code and generate the distribution files in the `dist/` directory.
-- `npm run preview`: Preview the built application.
-- `npm run test`: Run the test suite with Vitest.
+Why this works:
 
-## Contributing
+- the `Bridge.ports` column is the relationship that tells you which ports are attached to the bridge
+- when that set grows, something new was connected to the bridge
+- you can then inspect `Port` and `Interface` tables to resolve names or metadata for the newly attached objects
 
-Contributions are welcome! Please feel free to submit issues and pull requests.
+If you want richer correlation, monitor `Bridge`, `Port`, and `Interface` together and keep a small in-memory cache keyed by UUID so you can map a changed bridge port set back to the concrete port and interface names.
+
+Example: [examples/detect-interface-added.ts](/Users/alexanderslaa/WebstormProjects/github.com/SourceRegistry/node-ovsdb/examples/detect-interface-added.ts)
+
+## Common OVS Workflows
+
+These examples focus on patterns that show up often in virtualized environments, where OVS is used to connect VM or container networking to a virtual switch.
+
+### Create a Bridge With an Internal Interface
+
+What this does:
+
+- creates an `Interface` row of type `internal`
+- creates a `Port` that owns that interface
+- creates a `Bridge` that owns that port
+
+Why it is done this way:
+
+- in OVS, a bridge usually owns ports, and ports own interfaces
+- creating all three rows in one transaction keeps the change atomic
+- named UUIDs let later operations refer to rows inserted earlier in the same transaction
+
+Example: [examples/bridge-port-interface.ts](/Users/alexanderslaa/WebstormProjects/github.com/SourceRegistry/node-ovsdb/examples/bridge-port-interface.ts)
+
+### Attach a New Interface to an Existing Bridge
+
+What this does:
+
+- creates a new `Interface`
+- creates a `Port` that references that interface
+- mutates the existing bridge so the new port is added to its `ports` set
+
+Why this is a common pattern:
+
+- hypervisors and container hosts often attach new virtual NICs dynamically
+- mutating the bridge `ports` set avoids rewriting the whole bridge row
+- keeping it in one transaction prevents partial attachment state
+
+Example: [examples/attach-interface-to-bridge.ts](/Users/alexanderslaa/WebstormProjects/github.com/SourceRegistry/node-ovsdb/examples/attach-interface-to-bridge.ts)
+
+In practice, `type: "internal"` is useful when you want OVS itself to create the interface device. Leaving `type` unset is common when attaching an already existing device such as a tap interface created by a hypervisor.
+
+## Resource Management
+
+The client implements `AsyncDisposable`, so it also works with `await using` in runtimes that support explicit resource management.
+
+```ts
+await using client = new OVSDBClient();
+await client.connect();
+const dbs = await client.listDbs();
+```
+
+## Error Handling
+
+- Transport/request failures reject with `Error`
+- OVSDB JSON-RPC errors reject with `OvsdbRpcError`
+- malformed inbound frames emit `protocolError`
+- socket-level failures emit `transportError`
+
+## Documentation
+
+Generate API docs with Typedoc:
+
+```bash
+npm run docs:build
+```
+
+The public API is documented with TSDoc so the generated output is usable as a reference, not just a symbol dump.
+
+## Roadmap
+
+Planned work for the next iterations of the library:
+
+- relation-aware schema generation so UUID reference columns can emit stronger types such as `PortRef` or `InterfaceRef` instead of plain `Uuid`
+- richer codegen metadata for table relationships derived from `refTable` and `refType`
+- helper utilities for working with generated reference types in transactions and monitor snapshots
+- live TLS integration coverage for the transport and generator CLI
+- stricter runtime validation for inbound notifications and response payloads
+
+The intended direction is to make the generator more relation-aware first, before attempting a larger ORM-style layer.
+
+## Development
+
+```bash
+npm test
+npm run build
+npm run docs:build
+```
 
 ## License
 
-This project is licensed under the Apache-2.0 License. See the [LICENSE](LICENSE) file for details.
+Apache-2.0. See [LICENSE](./LICENSE).

package/bin/ovsdb-generate.cjs

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+
+const {runCli} = require("../dist-cli/cli.js");
+
+void runCli(process.argv.slice(2)).then((code) => {
+    process.exitCode = code;
+});

package/dist/cli.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Runs the OVSDB type generation CLI.
+ */
+export declare function runCli(argv: string[]): Promise<number>;
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":"AAwBA;;GAEG;AACH,wBAAsB,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,CAsD5D"}

package/dist/generator.d.ts

@@ -0,0 +1,136 @@
+import { OvsdbClientOptions } from './index';
+import { DatabaseSchema } from './types';
+/**
+ * Options for generating TypeScript types from an OVSDB schema.
+ */
+export interface GenerateTypesOptions {
+    /**
+     * The schema object to transform.
+     */
+    schema: DatabaseSchema;
+    /**
+     * Name of the generated top-level database type.
+     *
+     * @defaultValue Derived from `schema.name`
+     */
+    databaseTypeName?: string;
+    /**
+     * Module specifier used in generated imports.
+     *
+     * @defaultValue `"@sourceregistry/node-ovsdb"`
+     */
+    importFrom?: string;
+}
+/**
+ * CLI options for reading a schema and writing generated types.
+ */
+export interface GenerateTypesCliOptions {
+    /**
+     * Path to a schema JSON file. When set, live OVSDB access is skipped.
+     */
+    schemaPath?: string;
+    /**
+     * Unix socket path for live schema introspection.
+     */
+    socketPath?: string;
+    /**
+     * Hostname for live schema introspection over TCP or TLS.
+     */
+    host?: string;
+    /**
+     * Port for live schema introspection over TCP or TLS.
+     *
+     * @defaultValue `6640`
+     */
+    port?: number;
+    /**
+     * Enables TLS for live schema introspection.
+     */
+    tls?: boolean;
+    /**
+     * Disables TLS peer verification for environments that use self-signed certificates.
+     */
+    tlsInsecure?: boolean;
+    /**
+     * Explicit TLS server name used during handshake verification.
+     */
+    tlsServername?: string;
+    /**
+     * PEM CA bundle path used for TLS verification.
+     */
+    tlsCaFile?: string;
+    /**
+     * PEM client certificate path used for mutual TLS.
+     */
+    tlsCertFile?: string;
+    /**
+     * PEM client private key path used for mutual TLS.
+     */
+    tlsKeyFile?: string;
+    /**
+     * Database name used with live schema introspection.
+     *
+     * @defaultValue `"Open_vSwitch"`
+     */
+    databaseName?: string;
+    /**
+     * Destination file. When omitted, generated output is returned only.
+     */
+    outputPath?: string;
+    /**
+     * Name of the generated top-level database type.
+     */
+    databaseTypeName?: string;
+    /**
+     * Module specifier used in generated imports.
+     *
+     * @defaultValue `"@sourceregistry/node-ovsdb"`
+     */
+    importFrom?: string;
+}
+/**
+ * Generates TypeScript types from an OVSDB schema.
+ *
+ * The output is designed for direct use as the generic database model for
+ * {@link OVSDBClient}.
+ */
+export declare function generateTypesFromSchema(options: GenerateTypesOptions): string;
+/**
+ * Loads a schema from a file or a live OVSDB server and optionally writes the
+ * generated TypeScript output to disk.
+ */
+export declare function generateTypesFile(options: GenerateTypesCliOptions): Promise<string>;
+/**
+ * Reads a schema JSON file from disk.
+ */
+export declare function readSchemaFile(schemaPath: string): Promise<DatabaseSchema>;
+/**
+ * Reads a schema from a live OVSDB server.
+ */
+export declare function fetchSchemaFromOvsdb(options: {
+    socketPath?: string;
+    host?: string;
+    port?: number;
+    tls?: boolean;
+    tlsInsecure?: boolean;
+    tlsServername?: string;
+    tlsCaFile?: string;
+    tlsCertFile?: string;
+    tlsKeyFile?: string;
+    databaseName?: string;
+}): Promise<DatabaseSchema>;
+/**
+ * Builds client transport options for live schema introspection.
+ */
+export declare function createGeneratorClientOptions(options: {
+    socketPath?: string;
+    host?: string;
+    port?: number;
+    tls?: boolean;
+    tlsInsecure?: boolean;
+    tlsServername?: string;
+    tlsCaFile?: string;
+    tlsCertFile?: string;
+    tlsKeyFile?: string;
+}): Promise<OvsdbClientOptions>;
+//# sourceMappingURL=generator.d.ts.map

package/dist/generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generator.d.ts","sourceRoot":"","sources":["../src/generator.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAC,kBAAkB,EAAC,MAAM,SAAS,CAAC;AAChD,OAAO,KAAK,EAAuB,cAAc,EAAY,MAAM,SAAS,CAAC;AAE7E;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACjC;;OAEG;IACH,MAAM,EAAE,cAAc,CAAC;IAEvB;;;;OAIG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAE1B;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;CACvB;AAED;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACpC;;OAEG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB;;OAEG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB;;OAEG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IAEd;;;;OAIG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IAEd;;OAEG;IACH,GAAG,CAAC,EAAE,OAAO,CAAC;IAEd;;OAEG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;IAEtB;;OAEG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IAEvB;;OAEG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IAEnB;;OAEG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB;;OAEG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB;;;;OAIG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IAEtB;;OAEG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB;;OAEG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAE1B;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;CACvB;AAID;;;;;GAKG;AACH,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,oBAAoB,GAAG,MAAM,CA4D7E;AAED;;;GAGG;AACH,wBAAsB,iBAAiB,CAAC,OAAO,EAAE,uBAAuB,GAAG,OAAO,CAAC,MAAM,CAAC,CAazF;AAED;;GAEG;AACH,wBAAsB,cAAc,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC,CAGhF;AAED;;GAEG;AACH,wBAAsB,oBAAoB,CAAC,OAAO,EAAE;IAChD,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,GAAG,CAAC,EAAE,OAAO,CAAC;IACd,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,YAAY,CAAC,EAAE,MAAM,CAAC;CACzB,GAAG,OAAO,CAAC,cAAc,CAAC,CAS1B;AAqBD;;GAEG;AACH,wBAAsB,4BAA4B,CAAC,OAAO,EAAE;IACxD,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,GAAG,CAAC,EAAE,OAAO,CAAC;IACd,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,CAAC;CACvB,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAmB9B"}

package/dist/index.cjs

@@ -0,0 +1,3 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const v=require("node:fs"),m=require("node:net"),O=require("node:events"),q=require("node:tls");class f extends Error{response;constructor(t){super(t.details?`${t.error}: ${t.details}`:t.error),this.name="OvsdbRpcError",this.response=t}}class d extends Error{payload;constructor(t,e){super(t),this.name="OvsdbProtocolError",this.payload=e}}class w extends Error{operationIndex;operation;result;results;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 g{stagedOperations=[];get operations(){return this.stagedOperations}add(t){return this.stagedOperations.push(t),t}insert(t){return this.add(t)}select(t){return this.add(t)}update(t){return this.add(t)}mutate(t){return this.add(t)}delete(t){return this.add(t)}wait(t){return this.add(t)}comment(t){return this.add({op:"comment",comment:t})}assert(t){return this.add({op:"assert",lock:t})}commit(t=!1){return this.add({op:"commit",durable:t})}abort(){return this.add({op:"abort"})}}class y extends O.EventEmitter{timeout;connectionOptions;connectionFactory;socket=null;requestId=1;receiveBuffer="";pendingRequests=new Map;connected=!1;closeEmitted=!1;constructor(t={}){super(),this.timeout=t.timeout??5e3,this.connectionOptions=E(t),this.connectionFactory=t.connectionFactory}get isConnected(){return this.connected}async connect(){if(this.connected)return this;if(!this.connectionFactory&&this.connectionOptions.transport==="unix"&&!v.existsSync(this.connectionOptions.socketPath))throw new Error(`OVSDB socket not found: ${this.connectionOptions.socketPath}`);const t=this.connectionFactory?this.connectionFactory(this.connectionOptions):k(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}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)})})}async notify(t,e=[]){this.assertConnected(),await this.writeMessage({method:t,params:e})}async listDbs(){return await this.request("list_dbs",[])}async getSchema(t="Open_vSwitch"){return await this.request("get_schema",[t])}async transact(t,e){return await this.request("transact",[t,...e])}async transaction(t,e,s={}){const n=new g,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,l]of h.entries())if(b(l))throw new w({operationIndex:u,operation:o[u],result:l,results:h});return{value:a,operations:o,results:h}}async cancel(t){return await this.request("cancel",[t])}async monitor(t,e,s){return await this.request("monitor",[t,e,s])}async monitorCond(t,e,s){return await this.request("monitor_cond",[t,e,s])}async monitorCondSince(t,e,s,n=null){return await this.request("monitor_cond_since",[t,e,s,n])}async monitorCancel(t){return await this.request("monitor_cancel",[t])}async lock(t){return await this.request("lock",[t])}async steal(t){return await this.request("steal",[t])}async unlock(t){return await this.request("unlock",[t])}async echo(...t){return await this.request("echo",t)}async setDbChangeAware(t=!0){return await this.request("set_db_change_aware",[t])}async close(){this.disposeTransport()}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 d("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 f(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 d(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 E(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 k(r){switch(r.transport){case"unix":return m.createConnection(r.socketPath);case"tcp":return m.createConnection(r.port,r.host);case"tls":return q.connect(r.tlsOptions)}}function b(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}exports.OVSDBClient=y;exports.OvsdbProtocolError=d;exports.OvsdbRpcError=f;exports.OvsdbTransaction=g;exports.OvsdbTransactionError=w;exports.resolveConnectionOptions=E;
+//# sourceMappingURL=index.cjs.map