kubernetes-fluent-client 3.1.0 → 3.1.2

package/dist/fluent/index.test.js

@@ -0,0 +1,193 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const globals_1 = require("@jest/globals");
+const client_node_1 = require("@kubernetes/client-node");
+const _1 = require(".");
+const fetch_1 = require("../fetch");
+const upstream_1 = require("../upstream");
+const utils_1 = require("./utils");
+// Setup mocks
+globals_1.jest.mock("./utils");
+globals_1.jest.mock("../fetch");
+const generateFakePodManagedFields = (manager) => {
+    return [
+        {
+            apiVersion: "v1",
+            fieldsType: "FieldsV1",
+            fieldsV1: {
+                "f:metadata": {
+                    "f:labels": {
+                        "f:fake": {},
+                    },
+                    "f:spec": {
+                        "f:containers": {
+                            'k:{"name":"fake"}': {
+                                "f:image": {},
+                                "f:name": {},
+                                "f:resources": {
+                                    "f:limits": {
+                                        "f:cpu": {},
+                                        "f:memory": {},
+                                    },
+                                    "f:requests": {
+                                        "f:cpu": {},
+                                        "f:memory": {},
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+            manager: manager,
+            operation: "Apply",
+        },
+    ];
+};
+(0, globals_1.describe)("Kube", () => {
+    const fakeResource = {
+        metadata: {
+            name: "fake",
+            namespace: "default",
+            managedFields: generateFakePodManagedFields("pepr"),
+        },
+    };
+    const mockedKubeCfg = globals_1.jest.mocked(utils_1.k8sCfg);
+    const mockedKubeExec = globals_1.jest.mocked(utils_1.k8sExec).mockResolvedValue(fakeResource);
+    (0, globals_1.beforeEach)(() => {
+        // Clear all instances and calls to constructor and all methods:
+        mockedKubeExec.mockClear();
+    });
+    (0, globals_1.it)("should create a resource", async () => {
+        const result = await (0, _1.K8s)(upstream_1.Pod).Create(fakeResource);
+        (0, globals_1.expect)(result).toEqual(fakeResource);
+        (0, globals_1.expect)(mockedKubeExec).toHaveBeenCalledWith(upstream_1.Pod, globals_1.expect.objectContaining({
+            name: "fake",
+            namespace: "default",
+        }), "POST", fakeResource);
+    });
+    (0, globals_1.it)("should delete a resource", async () => {
+        await (0, _1.K8s)(upstream_1.Pod).Delete(fakeResource);
+        (0, globals_1.expect)(mockedKubeExec).toHaveBeenCalledWith(upstream_1.Pod, globals_1.expect.objectContaining({
+            name: "fake",
+            namespace: "default",
+        }), "DELETE");
+    });
+    (0, globals_1.it)("should patch a resource", async () => {
+        const patchOperations = [
+            { op: "replace", path: "/metadata/name", value: "new-fake" },
+        ];
+        const result = await (0, _1.K8s)(upstream_1.Pod).Patch(patchOperations);
+        (0, globals_1.expect)(result).toEqual(fakeResource);
+        (0, globals_1.expect)(mockedKubeExec).toHaveBeenCalledWith(upstream_1.Pod, {}, "PATCH", patchOperations);
+    });
+    (0, globals_1.it)("should patch the status of a resource", async () => {
+        await (0, _1.K8s)(upstream_1.Pod).PatchStatus({
+            metadata: {
+                name: "fake",
+                namespace: "default",
+                managedFields: generateFakePodManagedFields("pepr"),
+            },
+            spec: { priority: 3 },
+            status: {
+                phase: "Ready",
+            },
+        });
+        (0, globals_1.expect)(utils_1.k8sExec).toBeCalledWith(upstream_1.Pod, globals_1.expect.objectContaining({
+            name: "fake",
+            namespace: "default",
+        }), "PATCH_STATUS", {
+            apiVersion: "v1",
+            kind: "Pod",
+            metadata: {
+                name: "fake",
+                namespace: "default",
+                managedFields: generateFakePodManagedFields("pepr"),
+            },
+            spec: { priority: 3 },
+            status: {
+                phase: "Ready",
+            },
+        });
+    });
+    (0, globals_1.it)("should filter with WithField", async () => {
+        await (0, _1.K8s)(upstream_1.Pod).WithField("metadata.name", "fake").Get();
+        (0, globals_1.expect)(mockedKubeExec).toHaveBeenCalledWith(upstream_1.Pod, globals_1.expect.objectContaining({
+            fields: {
+                "metadata.name": "fake",
+            },
+        }), "GET");
+    });
+    (0, globals_1.it)("should filter with WithLabel", async () => {
+        await (0, _1.K8s)(upstream_1.Pod).WithLabel("app", "fakeApp").Get();
+        (0, globals_1.expect)(mockedKubeExec).toHaveBeenCalledWith(upstream_1.Pod, globals_1.expect.objectContaining({
+            labels: {
+                app: "fakeApp",
+            },
+        }), "GET");
+    });
+    (0, globals_1.it)("should use InNamespace", async () => {
+        await (0, _1.K8s)(upstream_1.Pod).InNamespace("fakeNamespace").Get();
+        (0, globals_1.expect)(mockedKubeExec).toHaveBeenCalledWith(upstream_1.Pod, globals_1.expect.objectContaining({
+            namespace: "fakeNamespace",
+        }), "GET");
+    });
+    (0, globals_1.it)("should throw an error if namespace is already specified", async () => {
+        (0, globals_1.expect)(() => (0, _1.K8s)(upstream_1.Pod, { namespace: "default" }).InNamespace("fakeNamespace")).toThrow("Namespace already specified: default");
+    });
+    (0, globals_1.it)("should handle Delete when the resource doesn't exist", async () => {
+        mockedKubeExec.mockRejectedValueOnce({ status: 404 }); // Not Found on first call
+        await (0, globals_1.expect)((0, _1.K8s)(upstream_1.Pod).Delete("fakeResource")).resolves.toBeUndefined();
+    });
+    (0, globals_1.it)("should handle Get", async () => {
+        const result = await (0, _1.K8s)(upstream_1.Pod).Get("fakeResource");
+        (0, globals_1.expect)(result).toEqual(fakeResource);
+        (0, globals_1.expect)(mockedKubeExec).toHaveBeenCalledWith(upstream_1.Pod, globals_1.expect.objectContaining({
+            name: "fakeResource",
+        }), "GET");
+    });
+    (0, globals_1.it)("should thrown an error if Get is called with a name and filters are already specified a name", async () => {
+        await (0, globals_1.expect)((0, _1.K8s)(upstream_1.Pod, { name: "fake" }).Get("fakeResource")).rejects.toThrow("Name already specified: fake");
+    });
+    (0, globals_1.it)("should throw an error if no patch operations provided", async () => {
+        await (0, globals_1.expect)((0, _1.K8s)(upstream_1.Pod).Patch([])).rejects.toThrow("No operations specified");
+    });
+    (0, globals_1.it)("should allow Apply of deep partials", async () => {
+        const result = await (0, _1.K8s)(upstream_1.Pod).Apply({ metadata: { name: "fake" }, spec: { priority: 3 } });
+        (0, globals_1.expect)(result).toEqual(fakeResource);
+    });
+    (0, globals_1.it)("should allow force apply to resolve FieldManagerConflict", async () => {
+        const result = await (0, _1.K8s)(upstream_1.Pod).Apply({
+            metadata: { name: "fake", managedFields: generateFakePodManagedFields("kubectl") },
+            spec: { priority: 3 },
+        }, { force: true });
+        (0, globals_1.expect)(result).toEqual(fakeResource);
+    });
+    (0, globals_1.it)("should throw an error if a Delete failed for a reason other than Not Found", async () => {
+        mockedKubeExec.mockRejectedValueOnce({ status: 500 }); // Internal Server Error on first call
+        await (0, globals_1.expect)((0, _1.K8s)(upstream_1.Pod).Delete("fakeResource")).rejects.toEqual(globals_1.expect.objectContaining({ status: 500 }));
+    });
+    (0, globals_1.it)("should create a raw api request", async () => {
+        mockedKubeCfg.mockReturnValue(new Promise(r => r({
+            serverUrl: "http://localhost:8080",
+            opts: {},
+        })));
+        const mockResp = {
+            kind: "APIVersions",
+            versions: ["v1"],
+            serverAddressByClientCIDRs: [
+                {
+                    serverAddress: "172.27.0.3:6443",
+                },
+            ],
+        };
+        globals_1.jest.mocked(fetch_1.fetch).mockResolvedValue({
+            ok: true,
+            data: mockResp,
+            status: 200,
+            statusText: "OK",
+        });
+        const result = await (0, _1.K8s)(client_node_1.V1APIGroup).Raw("/api");
+        (0, globals_1.expect)(result).toEqual(mockResp);
+    });
+});

package/dist/fluent/types.d.ts

@@ -0,0 +1,201 @@
+import { KubernetesListObject, KubernetesObject } from "@kubernetes/client-node";
+import { Operation } from "fast-json-patch";
+import type { PartialDeep } from "type-fest";
+import { GenericClass, GroupVersionKind } from "../types";
+import { WatchCfg, Watcher } from "./watch";
+import https from "https";
+import { SecureClientSessionOptions } from "http2";
+/**
+ * Agent options for the the http2Watch
+ */
+export type AgentOptions = Pick<SecureClientSessionOptions, "ca" | "cert" | "key" | "rejectUnauthorized">;
+/**
+ * Options for the http2Watch
+ */
+export interface Options {
+    agent?: https.Agent & {
+        options?: AgentOptions;
+    };
+}
+/**
+ * The Phase matched when using the K8s Watch API.
+ */
+export declare enum WatchPhase {
+    Added = "ADDED",
+    Modified = "MODIFIED",
+    Deleted = "DELETED",
+    Bookmark = "BOOKMARK",
+    Error = "ERROR"
+}
+export type FetchMethods = "GET" | "APPLY" | "POST" | "PUT" | "DELETE" | "PATCH" | "WATCH" | "PATCH_STATUS" | "LOG";
+export interface Filters {
+    kindOverride?: GroupVersionKind;
+    fields?: Record<string, string>;
+    labels?: Record<string, string>;
+    name?: string;
+    namespace?: string;
+}
+/**
+ * Get the resource or resources matching the filters.
+ * If no filters are specified, all resources will be returned.
+ * If a name is specified, only a single resource will be returned.
+ *
+ * @param name - (optional) the name of the resource to get
+ * @returns the resource or list of resources
+ */
+export type GetFunction<K extends KubernetesObject> = {
+    (): Promise<KubernetesListObject<K>>;
+    (name: string): Promise<K>;
+};
+export type K8sFilteredActions<T extends GenericClass, K extends KubernetesObject> = {
+    /**
+     * Gets the logs.
+     *
+     * @param name - the name of the Object to get logs from
+     * @returns array of logs
+     */
+    Logs: (name: string) => Promise<string[]>;
+    /**
+     * Get the resource or resources matching the filters.
+     * If no filters are specified, all resources will be returned.
+     * If a name is specified, only a single resource will be returned.
+     */
+    Get: GetFunction<K>;
+    /**
+     * Delete the resource matching the filters.
+     *
+     * @param filter - the resource or resource name to delete
+     */
+    Delete: (filter?: K | string) => Promise<void>;
+    /**
+     * Watch the resource matching the filters.
+     *
+     * @param callback - the callback function to call when an event occurs
+     * @param watchCfg - (optional) watch configuration
+     * @returns a watch controller
+     */
+    Watch: (callback: WatchAction<T>, watchCfg?: WatchCfg) => Watcher<T>;
+};
+export type K8sUnfilteredActions<K extends KubernetesObject> = {
+    /**
+     * Perform a server-side apply of the provided K8s resource.
+     *
+     * @param resource - the resource to apply
+     * @param applyCfg - (optional) apply configuration
+     * @returns the applied resource
+     */
+    Apply: (resource: PartialDeep<K>, applyCfg?: ApplyCfg) => Promise<K>;
+    /**
+     * Create the provided K8s resource or throw an error if it already exists.
+     *
+     * @param resource - the resource to create
+     * @returns the created resource
+     */
+    Create: (resource: K) => Promise<K>;
+    /**
+     * Advanced JSON Patch operations for when Server Side Apply, K8s().Apply(), is insufficient.
+     *
+     * Note: Throws an error on an empty list of patch operations.
+     *
+     * @param payload The patch operations to run
+     * @returns The patched resource
+     */
+    Patch: (payload: Operation[]) => Promise<K>;
+    /**
+     * Patch the status of the provided K8s resource. Note this is a special case of the Patch method that
+     * only allows patching the status subresource. This can be used in Operator reconciliation loops to
+     * update the status of a resource without triggering a new Generation of the resource.
+     *
+     * See https://stackoverflow.com/q/47100389/467373 for more details.
+     *
+     * IMPORTANT: This method will throw a 404 error if the resource does not have a status subresource defined.
+     *
+     * @param resource - the resource to patch
+     * @returns the patched resource
+     */
+    PatchStatus: (resource: PartialDeep<K>) => Promise<K>;
+    /**
+     * Perform a raw GET request to the Kubernetes API. This is useful for calling endpoints that are not supported by the fluent API.
+     * This command mirrors the `kubectl get --raw` command.
+     *
+     * E.g.
+     *
+     * ```ts
+     * import { V1APIGroup } from "@kubernetes/client-node";
+     *
+     * K8s(V1APIGroup).Raw("/api")
+     * ```
+     *
+     * will call the `/api` endpoint and is equivalent to `kubectl get --raw /api`.
+     *
+     * @param url the URL to call (e.g. /api)
+     * @returns
+     */
+    Raw: (url: string, method?: FetchMethods) => Promise<K>;
+};
+export type K8sWithFilters<T extends GenericClass, K extends KubernetesObject> = K8sFilteredActions<T, K> & {
+    /**
+     * Filter the query by the given field.
+     * Note multiple calls to this method will result in an AND condition. e.g.
+     *
+     * ```ts
+     * K8s(kind.Deployment)
+     * .WithField("metadata.name", "bar")
+     * .WithField("metadata.namespace", "qux")
+     * .Delete(...)
+     * ```
+     *
+     * Will only delete the Deployment if it has the `metadata.name=bar` and `metadata.namespace=qux` fields.
+     * Not all fields are supported, see https://kubernetes.io/docs/concepts/overview/working-with-objects/field-selectors/#supported-fields,
+     * but Typescript will limit to only fields that exist on the resource.
+     *
+     * @param key - the field key
+     * @param value - the field value
+     * @returns the fluent API
+     */
+    WithField: <P extends Paths<K>>(key: P, value: string) => K8sWithFilters<T, K>;
+    /**
+     * Filter the query by the given label. If no value is specified, the label simply must exist.
+     * Note multiple calls to this method will result in an AND condition. e.g.
+     *
+     * ```ts
+     * K8s(kind.Deployment)
+     * .WithLabel("foo", "bar")
+     * .WithLabel("baz", "qux")
+     * .WithLabel("quux")
+     * .Delete(...)
+     * ```
+     *
+     * Will only delete the Deployment if it has the`foo=bar` and `baz=qux` labels and the `quux` label exists.
+     *
+     * @param key - the label key
+     * @param value - the label value
+     * @returns the fluent API
+     */
+    WithLabel: (key: string, value?: string) => K8sWithFilters<T, K>;
+};
+/**
+ * Configuration for the apply function.
+ */
+export type ApplyCfg = {
+    /**
+     * Force the apply to be a create.
+     */
+    force?: boolean;
+};
+export type K8sInit<T extends GenericClass, K extends KubernetesObject> = K8sWithFilters<T, K> & K8sUnfilteredActions<K> & {
+    /**
+     * Set the namespace filter.
+     *
+     * @param namespace - the namespace to filter on
+     * @returns the fluent API
+     */
+    InNamespace: (namespace: string) => K8sWithFilters<T, K>;
+};
+export type WatchAction<T extends GenericClass, K extends KubernetesObject = InstanceType<T>> = (update: K, phase: WatchPhase) => Promise<void> | void;
+type Join<K, P> = K extends string | number ? P extends string | number ? `${K}${"" extends P ? "" : "."}${P}` : never : never;
+export type Paths<T, D extends number = 10> = [D] extends [never] ? never : T extends object ? {
+    [K in keyof T]-?: K extends string | number ? `${K}` | Join<K, Paths<T[K]>> : never;
+}[keyof T] : "";
+export {};
+//# sourceMappingURL=types.d.ts.map

package/dist/fluent/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/fluent/types.ts"],"names":[],"mappings":"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"}

package/dist/fluent/types.js

@@ -0,0 +1,16 @@
+"use strict";
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: 2023-Present The Kubernetes Fluent Client Authors
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WatchPhase = void 0;
+/**
+ * The Phase matched when using the K8s Watch API.
+ */
+var WatchPhase;
+(function (WatchPhase) {
+    WatchPhase["Added"] = "ADDED";
+    WatchPhase["Modified"] = "MODIFIED";
+    WatchPhase["Deleted"] = "DELETED";
+    WatchPhase["Bookmark"] = "BOOKMARK";
+    WatchPhase["Error"] = "ERROR";
+})(WatchPhase || (exports.WatchPhase = WatchPhase = {}));

package/dist/fluent/utils.d.ts

@@ -0,0 +1,41 @@
+import { URL } from "url";
+import { GenericClass } from "../types";
+import { ApplyCfg, FetchMethods, Filters } from "./types";
+/**
+ * Generate a path to a Kubernetes resource
+ *
+ * @param serverUrl - the URL of the Kubernetes API server
+ * @param model - the model to use for the API
+ * @param filters - (optional) filter overrides, can also be chained
+ * @param excludeName - (optional) exclude the name from the path
+ * @returns the path to the resource
+ */
+export declare function pathBuilder<T extends GenericClass>(serverUrl: string, model: T, filters: Filters, excludeName?: boolean): URL;
+/**
+ * Sets up the kubeconfig and https agent for a request
+ *
+ * A few notes:
+ * - The kubeconfig is loaded from the default location, and can check for in-cluster config
+ * - We have to create an agent to handle the TLS connection (for the custom CA + mTLS in some cases)
+ * - The K8s lib uses request instead of node-fetch today so the object is slightly different
+ *
+ * @param method - the HTTP method to use
+ * @returns the fetch options and server URL
+ */
+export declare function k8sCfg(method: FetchMethods): Promise<{
+    opts: import("node-fetch").RequestInit;
+    serverUrl: string;
+}>;
+/**
+ * Execute a request against the Kubernetes API server.
+ *
+ * @param model - the model to use for the API
+ * @param filters - (optional) filter overrides, can also be chained
+ * @param method - the HTTP method to use
+ * @param payload - (optional) the payload to send
+ * @param applyCfg - (optional) configuration for the apply method
+ *
+ * @returns the parsed JSON response
+ */
+export declare function k8sExec<T extends GenericClass, K>(model: T, filters: Filters, method: FetchMethods, payload?: K | unknown, applyCfg?: ApplyCfg): Promise<K>;
+//# sourceMappingURL=utils.d.ts.map

package/dist/fluent/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/fluent/utils.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,GAAG,EAAE,MAAM,KAAK,CAAC;AAI1B,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AACxC,OAAO,EAAE,QAAQ,EAAE,YAAY,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AAI1D;;;;;;;;GAQG;AACH,wBAAgB,WAAW,CAAC,CAAC,SAAS,YAAY,EAChD,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,CAAC,EACR,OAAO,EAAE,OAAO,EAChB,WAAW,UAAQ,OAwDpB;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,MAAM,CAAC,MAAM,EAAE,YAAY;;;GAwBhD;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,OAAO,CAAC,CAAC,SAAS,YAAY,EAAE,CAAC,EACrD,KAAK,EAAE,CAAC,EACR,OAAO,EAAE,OAAO,EAChB,MAAM,EAAE,YAAY,EACpB,OAAO,CAAC,EAAE,CAAC,GAAG,OAAO,EACrB,QAAQ,GAAE,QAA2B,cAwDtC"}

package/dist/fluent/utils.js

@@ -0,0 +1,153 @@
+"use strict";
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: 2023-Present The Kubernetes Fluent Client Authors
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pathBuilder = pathBuilder;
+exports.k8sCfg = k8sCfg;
+exports.k8sExec = k8sExec;
+const client_node_1 = require("@kubernetes/client-node");
+const url_1 = require("url");
+const fetch_1 = require("../fetch");
+const kinds_1 = require("../kinds");
+const SSA_CONTENT_TYPE = "application/apply-patch+yaml";
+/**
+ * Generate a path to a Kubernetes resource
+ *
+ * @param serverUrl - the URL of the Kubernetes API server
+ * @param model - the model to use for the API
+ * @param filters - (optional) filter overrides, can also be chained
+ * @param excludeName - (optional) exclude the name from the path
+ * @returns the path to the resource
+ */
+function pathBuilder(serverUrl, model, filters, excludeName = false) {
+    const matchedKind = filters.kindOverride || (0, kinds_1.modelToGroupVersionKind)(model.name);
+    // If the kind is not specified and the model is not a KubernetesObject, throw an error
+    if (!matchedKind) {
+        throw new Error(`Kind not specified for ${model.name}`);
+    }
+    // Use the plural property if it exists, otherwise use lowercase kind + s
+    const plural = matchedKind.plural || `${matchedKind.kind.toLowerCase()}s`;
+    let base = "/api/v1";
+    // If the kind is not in the core group, add the group and version to the path
+    if (matchedKind.group) {
+        if (!matchedKind.version) {
+            throw new Error(`Version not specified for ${model.name}`);
+        }
+        base = `/apis/${matchedKind.group}/${matchedKind.version}`;
+    }
+    // Namespaced paths require a namespace prefix
+    const namespace = filters.namespace ? `namespaces/${filters.namespace}` : "";
+    // Name should not be included in some paths
+    const name = excludeName ? "" : filters.name;
+    // Build the complete path to the resource
+    const path = [base, namespace, plural, name].filter(Boolean).join("/");
+    // Generate the URL object
+    const url = new url_1.URL(path, serverUrl);
+    // Add field selectors to the query params
+    if (filters.fields) {
+        const fieldSelector = Object.entries(filters.fields)
+            .map(([key, value]) => `${key}=${value}`)
+            .join(",");
+        url.searchParams.set("fieldSelector", fieldSelector);
+    }
+    // Add label selectors to the query params
+    if (filters.labels) {
+        const labelSelector = Object.entries(filters.labels)
+            // Exists set-based operators only include the key
+            // See https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/#set-based-requirement
+            .map(([key, value]) => (value ? `${key}=${value}` : key))
+            .join(",");
+        url.searchParams.set("labelSelector", labelSelector);
+    }
+    return url;
+}
+/**
+ * Sets up the kubeconfig and https agent for a request
+ *
+ * A few notes:
+ * - The kubeconfig is loaded from the default location, and can check for in-cluster config
+ * - We have to create an agent to handle the TLS connection (for the custom CA + mTLS in some cases)
+ * - The K8s lib uses request instead of node-fetch today so the object is slightly different
+ *
+ * @param method - the HTTP method to use
+ * @returns the fetch options and server URL
+ */
+async function k8sCfg(method) {
+    const kubeConfig = new client_node_1.KubeConfig();
+    kubeConfig.loadFromDefault();
+    const cluster = kubeConfig.getCurrentCluster();
+    if (!cluster) {
+        throw new Error("No currently active cluster");
+    }
+    // Setup the TLS options & auth headers, as needed
+    const opts = await kubeConfig.applyToFetchOptions({
+        method,
+        headers: {
+            // Set the default content type to JSON
+            "Content-Type": "application/json",
+            // Set the user agent like kubectl does
+            "User-Agent": `kubernetes-fluent-client`,
+        },
+    });
+    // Enable compression
+    opts.compress = true;
+    return { opts, serverUrl: cluster.server };
+}
+/**
+ * Execute a request against the Kubernetes API server.
+ *
+ * @param model - the model to use for the API
+ * @param filters - (optional) filter overrides, can also be chained
+ * @param method - the HTTP method to use
+ * @param payload - (optional) the payload to send
+ * @param applyCfg - (optional) configuration for the apply method
+ *
+ * @returns the parsed JSON response
+ */
+async function k8sExec(model, filters, method, payload, applyCfg = { force: false }) {
+    const reconstruct = async (method) => {
+        const configMethod = method === "LOG" ? "GET" : method;
+        const { opts, serverUrl } = await k8sCfg(configMethod);
+        const isPost = method === "POST";
+        const baseUrl = pathBuilder(serverUrl, model, filters, isPost);
+        if (method === "LOG") {
+            baseUrl.pathname = `${baseUrl.pathname}/log`;
+        }
+        return {
+            url: baseUrl,
+            opts,
+        };
+    };
+    const { opts, url } = await reconstruct(method);
+    switch (opts.method) {
+        // PATCH_STATUS is a special case that uses the PATCH method on status subresources
+        case "PATCH_STATUS":
+            opts.method = "PATCH";
+            url.pathname = `${url.pathname}/status`;
+            opts.headers.set("Content-Type", client_node_1.PatchStrategy.MergePatch);
+            payload = { status: payload.status };
+            break;
+        case "PATCH":
+            opts.headers.set("Content-Type", client_node_1.PatchStrategy.JsonPatch);
+            break;
+        case "APPLY":
+            opts.headers.set("Content-Type", SSA_CONTENT_TYPE);
+            opts.method = "PATCH";
+            url.searchParams.set("fieldManager", "pepr");
+            url.searchParams.set("fieldValidation", "Strict");
+            url.searchParams.set("force", applyCfg.force ? "true" : "false");
+            break;
+    }
+    if (payload) {
+        opts.body = JSON.stringify(payload);
+    }
+    const resp = await (0, fetch_1.fetch)(url, opts);
+    if (resp.ok) {
+        return resp.data;
+    }
+    if (resp.status === 404 && method === "PATCH_STATUS") {
+        resp.statusText =
+            "Not Found" + " (NOTE: This error is expected if the resource has no status subresource)";
+    }
+    throw resp;
+}

package/dist/fluent/utils.test.d.ts

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

package/dist/fluent/utils.test.d.ts.map

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