kubernetes-fluent-client 1.10.0 → 2.0.0

package/dist/fluent/watch.js

@@ -5,147 +5,322 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ExecWatch = void 0;
+exports.Watcher = exports.WatchEvent = void 0;
 const byline_1 = __importDefault(require("byline"));
+const crypto_1 = require("crypto");
+const events_1 = require("events");
 const node_fetch_1 = __importDefault(require("node-fetch"));
+const types_1 = require("./types");
 const utils_1 = require("./utils");
-/**
- * Execute a watch on the specified resource.
- *
- * @param model - the model to use for the API
- * @param filters - (optional) filter overrides, can also be chained
- * @param callback - the callback function to call when an event is received
- * @param watchCfg - (optional) watch configuration
- * @returns a WatchController to allow the watch to be aborted externally
- */
-async function ExecWatch(model, filters, callback, watchCfg = {}) {
-    watchCfg.logFn?.({ model, filters, watchCfg }, "ExecWatch");
-    // Build the path and query params for the resource, excluding the name
-    const { opts, serverUrl } = await (0, utils_1.k8sCfg)("GET");
-    const url = (0, utils_1.pathBuilder)(serverUrl, model, filters, true);
-    // Enable the watch query param
-    url.searchParams.set("watch", "true");
-    // Allow bookmarks to be used for the watch
-    url.searchParams.set("allowWatchBookmarks", "true");
-    // If a name is specified, add it to the query params
-    if (filters.name) {
-        url.searchParams.set("fieldSelector", `metadata.name=${filters.name}`);
-    }
-    // Set the initial timeout to 15 seconds
-    opts.timeout = 15 * 1000;
-    // Enable keep alive
-    opts.agent.keepAlive = true;
-    // Track the number of retries
-    let retryCount = 0;
-    // Set the maximum number of retries to 5 if not specified
-    watchCfg.retryMax ??= 5;
-    // Set the retry delay to 5 seconds if not specified
-    watchCfg.retryDelaySec ??= 5;
-    // Create a throwaway AbortController to setup the wrapped AbortController
-    let abortController;
+var WatchEvent;
+(function (WatchEvent) {
+    /** Watch is connected successfully */
+    WatchEvent["CONNECT"] = "connect";
+    /** Network error occurs */
+    WatchEvent["NETWORK_ERROR"] = "network_error";
+    /** Error decoding data or running the callback */
+    WatchEvent["DATA_ERROR"] = "data_error";
+    /** Reconnect is called */
+    WatchEvent["RECONNECT"] = "reconnect";
+    /** Retry limit is exceeded */
+    WatchEvent["GIVE_UP"] = "give_up";
+    /** Abort is called */
+    WatchEvent["ABORT"] = "abort";
+    /** Resync is called */
+    WatchEvent["RESYNC"] = "resync";
+    /** Data is received and decoded */
+    WatchEvent["DATA"] = "data";
+    /** Bookmark is received */
+    WatchEvent["BOOKMARK"] = "bookmark";
+    /** ResourceVersion is updated */
+    WatchEvent["RESOURCE_VERSION"] = "resource_version";
+    /** 410 (old resource version) occurs */
+    WatchEvent["OLD_RESOURCE_VERSION"] = "old_resource_version";
+    /** A reconnect is already pending */
+    WatchEvent["RECONNECT_PENDING"] = "reconnect_pending";
+})(WatchEvent || (exports.WatchEvent = WatchEvent = {}));
+/** A wrapper around the Kubernetes watch API. */
+class Watcher {
+    // User-provided properties
+    #model;
+    #filters;
+    #callback;
+    #watchCfg;
     // Create a wrapped AbortController to allow the watch to be aborted externally
-    const abortWrapper = {};
+    #abortController;
+    // Track the number of retries
+    #retryCount = 0;
+    // Create a stream to read the response body
+    #stream;
+    // Create an EventEmitter to emit events
+    #events = new events_1.EventEmitter();
+    // Create a timer to resync the watch
+    #resyncTimer;
+    // Unique ID for the watch
+    #id;
+    #hashedID;
+    // Track if a reconnect is pending
+    #pendingReconnect = false;
     /**
-     * Bind the abort controller to the wrapper.
+     * Setup a Kubernetes watcher for the specified model and filters. The callback function will be called for each event received.
+     * The watch can be aborted by calling {@link Watcher.close} or by calling abort() on the AbortController returned by {@link Watcher.start}.
+     *
+     *
+     * Kubernetes API docs: {@link https://kubernetes.io/docs/reference/using-api/api-concepts/#efficient-detection-of-changes}
+     *
+     * @param model - the model to use for the API
+     * @param filters - (optional) filter overrides, can also be chained
+     * @param callback - the callback function to call when an event is received
+     * @param watchCfg - (optional) watch configuration
      */
-    function bindAbortController() {
+    constructor(model, filters, callback, watchCfg = {}) {
+        // Set the retry delay to 10 seconds if not specified
+        watchCfg.retryDelaySec ??= 10;
+        // Set the resync interval to 5 minutes if not specified
+        watchCfg.resyncIntervalSec ??= 300;
+        // Bind class properties
+        this.#model = model;
+        this.#filters = filters;
+        this.#callback = callback;
+        this.#watchCfg = watchCfg;
         // Create a new AbortController
-        abortController = new AbortController();
-        // Update the abort wrapper
-        abortWrapper.abort = reason => abortController.abort(reason);
-        abortWrapper.signal = () => abortController.signal;
-        // Add the abort signal to the request options
-        opts.signal = abortController.signal;
+        this.#abortController = new AbortController();
     }
     /**
-     * The main watch runner. This will run until the process is terminated or the watch is aborted.
+     * Start the watch.
+     *
+     * @returns The AbortController for the watch.
      */
-    async function runner() {
-        let doneCalled = false;
-        bindAbortController();
-        // Create a stream to read the response body
-        const stream = byline_1.default.createStream();
-        const onError = (err) => {
-            stream.removeAllListeners();
-            if (!doneCalled) {
-                doneCalled = true;
-                // If the error is not an AbortError, reload the watch
-                if (err.name !== "AbortError") {
-                    watchCfg.logFn?.(err, "stream error");
-                    void reload(err);
-                }
-                else {
-                    watchCfg.logFn?.("watch aborted via WatchController.abort()");
-                }
-            }
-        };
-        // Cleanup the stream listeners
-        const cleanup = () => {
-            if (!doneCalled) {
-                doneCalled = true;
-                stream.removeAllListeners();
-            }
-        };
+    async start() {
+        await this.#runner();
+        return this.#abortController;
+    }
+    /** Close the watch. Also available on the AbortController returned by {@link Watcher.start}. */
+    close() {
+        clearTimeout(this.#resyncTimer);
+        this.#cleanup();
+        this.#abortController.abort();
+    }
+    /**
+     * Get a unique ID for the watch based on the model and filters.
+     * This is useful for caching the watch data or resource versions.
+     *
+     * @returns the watch ID
+     */
+    get id() {
+        // The ID must exist at this point
+        if (!this.#id) {
+            throw new Error("watch not started");
+        }
+        // Hash and truncate the ID to 10 characters, cache the result
+        if (!this.#hashedID) {
+            this.#hashedID = (0, crypto_1.createHash)("sha224").update(this.#id).digest("hex").substring(0, 10);
+        }
+        return this.#hashedID;
+    }
+    /**
+     * Subscribe to watch events. This is an EventEmitter that emits the following events:
+     *
+     * Use {@link WatchEvent} for the event names.
+     *
+     * @returns an EventEmitter
+     */
+    get events() {
+        return this.#events;
+    }
+    /**
+     * Build the URL and request options for the watch.
+     *
+     * @returns the URL and request options
+     */
+    #buildURL = async () => {
+        // Build the path and query params for the resource, excluding the name
+        const { opts, serverUrl } = await (0, utils_1.k8sCfg)("GET");
+        const url = (0, utils_1.pathBuilder)(serverUrl, this.#model, this.#filters, true);
+        // Set the watch ID if it does not exist (this does not change on reconnect)
+        if (!this.#id) {
+            this.#id = url.pathname + url.search;
+        }
+        // Enable the watch query param
+        url.searchParams.set("watch", "true");
+        // If a name is specified, add it to the query params
+        if (this.#filters.name) {
+            url.searchParams.set("fieldSelector", `metadata.name=${this.#filters.name}`);
+        }
+        // If a resource version is specified, add it to the query params
+        if (this.#watchCfg.resourceVersion) {
+            url.searchParams.set("resourceVersion", this.#watchCfg.resourceVersion);
+        }
+        // Enable watch bookmarks
+        url.searchParams.set("allowWatchBookmarks", "true");
+        // Add the abort signal to the request options
+        opts.signal = this.#abortController.signal;
+        return { opts, url };
+    };
+    /** Run the watch. */
+    #runner = async () => {
         try {
+            // Build the URL and request options
+            const { opts, url } = await this.#buildURL();
+            // Create a stream to read the response body
+            this.#stream = byline_1.default.createStream();
+            // Bind the stream events
+            this.#stream.on("error", this.#errHandler);
+            this.#stream.on("close", this.#cleanup);
+            this.#stream.on("finish", this.#cleanup);
             // Make the actual request
             const response = await (0, node_fetch_1.default)(url, { ...opts });
+            // Reset the pending reconnect flag
+            this.#pendingReconnect = false;
+            // Reset the resync timer
+            void this.#scheduleResync();
             // If the request is successful, start listening for events
             if (response.ok) {
+                this.#events.emit(WatchEvent.CONNECT);
                 const { body } = response;
                 // Reset the retry count
-                retryCount = 0;
-                stream.on("error", onError);
-                stream.on("close", cleanup);
-                stream.on("finish", cleanup);
+                this.#retryCount = 0;
                 // Listen for events and call the callback function
-                stream.on("data", line => {
+                this.#stream.on("data", async (line) => {
                     try {
                         // Parse the event payload
                         const { object: payload, type: phase } = JSON.parse(line);
-                        // Call the callback function with the parsed payload
-                        void callback(payload, phase);
+                        void this.#scheduleResync();
+                        // If the watch is too old, remove the resourceVersion and reload the watch
+                        if (phase === types_1.WatchPhase.Error && payload.code === 410) {
+                            throw {
+                                name: "TooOld",
+                                message: this.#watchCfg.resourceVersion,
+                            };
+                        }
+                        // If the event is a bookmark, emit the event and skip the callback
+                        if (phase === types_1.WatchPhase.Bookmark) {
+                            this.#events.emit(WatchEvent.BOOKMARK, payload);
+                        }
+                        else {
+                            this.#events.emit(WatchEvent.DATA, payload, phase);
+                            // Call the callback function with the parsed payload
+                            await this.#callback(payload, phase);
+                        }
+                        // Update the resource version if the callback was successful
+                        this.#setResourceVersion(payload.metadata.resourceVersion);
                     }
                     catch (err) {
-                        watchCfg.logFn?.(err, "watch callback error");
+                        if (err.name === "TooOld") {
+                            // Prevent any body events from firing
+                            body.removeAllListeners();
+                            // Reload the watch
+                            void this.#errHandler(err);
+                            return;
+                        }
+                        this.#events.emit(WatchEvent.DATA_ERROR, err);
                     }
                 });
-                body.on("error", onError);
-                body.on("close", cleanup);
-                body.on("finish", cleanup);
+                // Bind the body events
+                body.on("error", this.#errHandler);
+                body.on("close", this.#cleanup);
+                body.on("finish", this.#cleanup);
                 // Pipe the response body to the stream
-                body.pipe(stream);
+                body.pipe(this.#stream);
             }
             else {
-                throw new Error(`watch failed: ${response.status} ${response.statusText}`);
+                throw new Error(`watch connect failed: ${response.status} ${response.statusText}`);
             }
         }
         catch (e) {
-            onError(e);
+            void this.#errHandler(e);
         }
-        /**
-         * Reload the watch.
-         *
-         * @param e - the error that caused the reload
-         */
-        async function reload(e) {
-            // If there are more attempts, retry the watch
-            if (watchCfg.retryMax > retryCount) {
-                retryCount++;
-                watchCfg.logFn?.(`retrying watch ${retryCount}/${watchCfg.retryMax}`);
-                // Sleep for the specified delay or 5 seconds
-                await new Promise(r => setTimeout(r, watchCfg.retryDelaySec * 1000));
-                // Retry the watch after the delay
-                await runner();
+    };
+    /**
+     * Resync the watch.
+     *
+     * @returns the error handler
+     */
+    #resync = () => this.#errHandler({
+        name: "Resync",
+        message: "Resync triggered by resyncIntervalSec",
+    });
+    /** Clear the resync timer and schedule a new one. */
+    #scheduleResync = async () => {
+        clearTimeout(this.#resyncTimer);
+        this.#resyncTimer = setTimeout(this.#resync, this.#watchCfg.resyncIntervalSec * 1000);
+    };
+    /**
+     * Update the resource version.
+     *
+     * @param resourceVersion - the new resource version
+     */
+    #setResourceVersion = (resourceVersion) => {
+        this.#watchCfg.resourceVersion = resourceVersion;
+        this.#events.emit(WatchEvent.RESOURCE_VERSION, resourceVersion);
+    };
+    /**
+     * Reload the watch after an error.
+     *
+     * @param err - the error that occurred
+     */
+    #reconnect = async (err) => {
+        // If there are more attempts, retry the watch (undefined is unlimited retries)
+        if (this.#watchCfg.retryMax === undefined || this.#watchCfg.retryMax > this.#retryCount) {
+            // Sleep for the specified delay, but check every 500ms if the watch has been aborted
+            let delay = this.#watchCfg.retryDelaySec * 1000;
+            while (delay > 0) {
+                if (this.#abortController.signal.aborted) {
+                    return;
+                }
+                delay -= 500;
+                await new Promise(resolve => setTimeout(resolve, 500));
+            }
+            this.#retryCount++;
+            this.#events.emit(WatchEvent.RECONNECT, err, this.#retryCount);
+            if (this.#pendingReconnect) {
+                this.#events.emit(WatchEvent.RECONNECT_PENDING);
             }
             else {
-                // Otherwise, call the finally function if it exists
-                if (watchCfg.retryFail) {
-                    watchCfg.retryFail(e);
-                }
+                this.#pendingReconnect = true;
+                this.#cleanup();
+                // Retry the watch after the delay
+                await this.#runner();
             }
         }
-    }
-    await runner();
-    return abortWrapper;
+        else {
+            // Otherwise, call the finally function if it exists
+            this.#events.emit(WatchEvent.GIVE_UP, err);
+            this.close();
+        }
+    };
+    /**
+     * Handle errors from the stream.
+     *
+     * @param err - the error that occurred
+     */
+    #errHandler = async (err) => {
+        switch (err.name) {
+            case "AbortError":
+                clearTimeout(this.#resyncTimer);
+                this.#cleanup();
+                this.#events.emit(WatchEvent.ABORT, err);
+                return;
+            case "TooOld":
+                // Purge the resource version if it is too old
+                this.#setResourceVersion(undefined);
+                this.#events.emit(WatchEvent.OLD_RESOURCE_VERSION, err.message);
+                break;
+            case "Resync":
+                this.#events.emit(WatchEvent.RESYNC, err);
+                break;
+            default:
+                this.#events.emit(WatchEvent.NETWORK_ERROR, err);
+                break;
+        }
+        await this.#reconnect(err);
+    };
+    /** Cleanup the stream and listeners. */
+    #cleanup = () => {
+        if (this.#stream) {
+            this.#stream.removeAllListeners();
+            this.#stream.destroy();
+        }
+    };
 }
-exports.ExecWatch = ExecWatch;
+exports.Watcher = Watcher;

package/dist/fluent/watch.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=watch.spec.d.ts.map

package/dist/fluent/watch.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"watch.spec.d.ts","sourceRoot":"","sources":["../../src/fluent/watch.spec.ts"],"names":[],"mappings":""}

package/dist/fluent/watch.spec.js

@@ -0,0 +1,221 @@
+"use strict";
+/* eslint-disable @typescript-eslint/no-explicit-any */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const globals_1 = require("@jest/globals");
+const nock_1 = __importDefault(require("nock"));
+const readable_stream_1 = require("readable-stream");
+const _1 = require(".");
+const __1 = require("..");
+const types_1 = require("./types");
+(0, globals_1.describe)("Watcher", () => {
+    const evtMock = globals_1.jest.fn();
+    const errMock = globals_1.jest.fn();
+    const setupAndStartWatcher = (eventType, handler) => {
+        watcher.events.on(eventType, handler);
+        watcher.start().catch(errMock);
+    };
+    let watcher;
+    (0, globals_1.beforeEach)(() => {
+        globals_1.jest.resetAllMocks();
+        watcher = (0, _1.K8s)(__1.kind.Pod).Watch(evtMock, {
+            retryDelaySec: 1,
+        });
+        (0, nock_1.default)("http://jest-test:8080")
+            .get("/api/v1/pods")
+            .query({ watch: "true", allowWatchBookmarks: "true" })
+            .reply(200, () => {
+            const stream = new readable_stream_1.PassThrough();
+            const resources = [
+                { type: "ADDED", object: createMockPod(`pod-0`, `1`) },
+                { type: "BOOKMARK", object: { metadata: { resourceVersion: "1" } } },
+                { type: "MODIFIED", object: createMockPod(`pod-0`, `2`) },
+            ];
+            resources.forEach(resource => {
+                stream.write(JSON.stringify(resource) + "\n");
+            });
+            stream.end();
+            return stream;
+        });
+    });
+    (0, globals_1.afterEach)(() => {
+        watcher.close();
+    });
+    (0, globals_1.it)("should watch named resources", done => {
+        nock_1.default.cleanAll();
+        (0, nock_1.default)("http://jest-test:8080")
+            .get("/api/v1/namespaces/tester/pods")
+            .query({ watch: "true", allowWatchBookmarks: "true", fieldSelector: "metadata.name=demo" })
+            .reply(200);
+        watcher = (0, _1.K8s)(__1.kind.Pod, { name: "demo" }).InNamespace("tester").Watch(evtMock);
+        setupAndStartWatcher(__1.WatchEvent.CONNECT, () => {
+            done();
+        });
+    });
+    (0, globals_1.it)("should start the watch at the specified resource version", done => {
+        nock_1.default.cleanAll();
+        (0, nock_1.default)("http://jest-test:8080")
+            .get("/api/v1/pods")
+            .query({
+            watch: "true",
+            allowWatchBookmarks: "true",
+            resourceVersion: "25",
+        })
+            .reply(200);
+        watcher = (0, _1.K8s)(__1.kind.Pod).Watch(evtMock, {
+            resourceVersion: "25",
+        });
+        setupAndStartWatcher(__1.WatchEvent.CONNECT, () => {
+            done();
+        });
+    });
+    (0, globals_1.it)("should handle resource version is too old", done => {
+        nock_1.default.cleanAll();
+        (0, nock_1.default)("http://jest-test:8080")
+            .get("/api/v1/pods")
+            .query({ watch: "true", allowWatchBookmarks: "true", resourceVersion: "45" })
+            .reply(200, () => {
+            const stream = new readable_stream_1.PassThrough();
+            stream.write(JSON.stringify({
+                type: "ERROR",
+                object: {
+                    kind: "Status",
+                    apiVersion: "v1",
+                    metadata: {},
+                    status: "Failure",
+                    message: "too old resource version: 123 (391079)",
+                    reason: "Gone",
+                    code: 410,
+                },
+            }) + "\n");
+            stream.end();
+            return stream;
+        });
+        watcher = (0, _1.K8s)(__1.kind.Pod).Watch(evtMock, {
+            resourceVersion: "45",
+        });
+        setupAndStartWatcher(__1.WatchEvent.OLD_RESOURCE_VERSION, res => {
+            (0, globals_1.expect)(res).toEqual("45");
+            done();
+        });
+    });
+    (0, globals_1.it)("should call the event handler for each event", done => {
+        watcher = (0, _1.K8s)(__1.kind.Pod).Watch((evt, phase) => {
+            (0, globals_1.expect)(evt.metadata?.name).toEqual(`pod-0`);
+            (0, globals_1.expect)(phase).toEqual(types_1.WatchPhase.Added);
+            done();
+        });
+        watcher.start().catch(errMock);
+    });
+    (0, globals_1.it)("should return the cache id", done => {
+        watcher
+            .start()
+            .then(() => {
+            (0, globals_1.expect)(watcher.id).toEqual("d69b75a611");
+            done();
+        })
+            .catch(errMock);
+    });
+    (0, globals_1.it)("should handle calling .id() before .start()", () => {
+        (0, globals_1.expect)(() => watcher.id).toThrowError("watch not started");
+    });
+    (0, globals_1.it)("should handle the CONNECT event", done => {
+        setupAndStartWatcher(__1.WatchEvent.CONNECT, () => {
+            done();
+        });
+    });
+    (0, globals_1.it)("should handle the DATA event", done => {
+        setupAndStartWatcher(__1.WatchEvent.DATA, (pod, phase) => {
+            (0, globals_1.expect)(pod.metadata?.name).toEqual(`pod-0`);
+            (0, globals_1.expect)(phase).toEqual(types_1.WatchPhase.Added);
+            done();
+        });
+    });
+    (0, globals_1.it)("should handle the BOOKMARK event", done => {
+        setupAndStartWatcher(__1.WatchEvent.BOOKMARK, bookmark => {
+            (0, globals_1.expect)(bookmark.metadata?.resourceVersion).toEqual("1");
+            done();
+        });
+    });
+    (0, globals_1.it)("should handle the NETWORK_ERROR event", done => {
+        nock_1.default.cleanAll();
+        (0, nock_1.default)("http://jest-test:8080")
+            .get("/api/v1/pods")
+            .query({ watch: "true", allowWatchBookmarks: "true" })
+            .replyWithError("Something bad happened");
+        setupAndStartWatcher(__1.WatchEvent.NETWORK_ERROR, error => {
+            (0, globals_1.expect)(error.message).toEqual("request to http://jest-test:8080/api/v1/pods?watch=true&allowWatchBookmarks=true failed, reason: Something bad happened");
+            done();
+        });
+    });
+    (0, globals_1.it)("should handle the RECONNECT event", done => {
+        nock_1.default.cleanAll();
+        (0, nock_1.default)("http://jest-test:8080")
+            .get("/api/v1/pods")
+            .query({ watch: "true", allowWatchBookmarks: "true" })
+            .replyWithError("Something bad happened");
+        setupAndStartWatcher(__1.WatchEvent.RECONNECT, error => {
+            (0, globals_1.expect)(error.message).toEqual("request to http://jest-test:8080/api/v1/pods?watch=true&allowWatchBookmarks=true failed, reason: Something bad happened");
+            done();
+        });
+    });
+    (0, globals_1.it)("should perform a resync after the resync interval", done => {
+        watcher = (0, _1.K8s)(__1.kind.Pod).Watch(evtMock, {
+            resyncIntervalSec: 1,
+        });
+        setupAndStartWatcher(__1.WatchEvent.RESYNC, err => {
+            (0, globals_1.expect)(err.name).toEqual("Resync");
+            (0, globals_1.expect)(err.message).toEqual("Resync triggered by resyncIntervalSec");
+            done();
+        });
+    });
+    (0, globals_1.it)("should handle the GIVE_UP event", done => {
+        nock_1.default.cleanAll();
+        (0, nock_1.default)("http://jest-test:8080");
+        watcher = (0, _1.K8s)(__1.kind.Pod).Watch(evtMock, {
+            retryMax: 1,
+            retryDelaySec: 1,
+        });
+        setupAndStartWatcher(__1.WatchEvent.GIVE_UP, error => {
+            (0, globals_1.expect)(error.message).toContain("request to http://jest-test:8080/api/v1/pods?watch=true&allowWatchBookmarks=true failed");
+            done();
+        });
+    });
+});
+/**
+ * Creates a mock pod object
+ *
+ * @param name The name of the pod
+ * @param resourceVersion The resource version of the pod
+ * @returns A mock pod object
+ */
+function createMockPod(name, resourceVersion) {
+    return {
+        kind: "Pod",
+        apiVersion: "v1",
+        metadata: {
+            name: name,
+            resourceVersion: resourceVersion,
+            // ... other metadata fields
+        },
+        spec: {
+            containers: [
+                {
+                    name: "nginx",
+                    image: "nginx:1.14.2",
+                    ports: [
+                        {
+                            containerPort: 80,
+                            protocol: "TCP",
+                        },
+                    ],
+                },
+            ],
+        },
+        status: {
+        // ... pod status
+        },
+    };
+}

package/dist/index.d.ts

@@ -4,6 +4,7 @@ import * as kind from "./upstream";
 export { kind };
 export { fetch } from "./fetch";
 export { StatusCodes as fetchStatus } from "http-status-codes";
+export { WatchCfg, WatchEvent } from "./fluent/watch";
 export { K8s } from "./fluent";
 export { RegisterKind, modelToGroupVersionKind } from "./kinds";
 export { GenericKind } from "./types";