kubernetes-fluent-client 0.0.0-development → 1.1.0

package/dist/fluent/utils.js

@@ -0,0 +1,116 @@
+"use strict";
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: 2023-Present The Pepr Authors
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.k8sExec = exports.k8sCfg = exports.pathBuilder = void 0;
+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
+ * @param model
+ * @param filters
+ * @param excludeName
+ * @returns
+ */
+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)
+            .map(([key, value]) => `${key}=${value}`)
+            .join(",");
+        url.searchParams.set("labelSelector", labelSelector);
+    }
+    return url;
+}
+exports.pathBuilder = pathBuilder;
+/**
+ * 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
+ * @returns
+ */
+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`,
+        },
+    });
+    return { opts, serverUrl: cluster.server };
+}
+exports.k8sCfg = k8sCfg;
+async function k8sExec(model, filters, method, payload) {
+    const { opts, serverUrl } = await k8sCfg(method);
+    const url = pathBuilder(serverUrl, model, filters, method === "POST");
+    switch (opts.method) {
+        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", "false");
+            break;
+    }
+    if (payload) {
+        opts.body = JSON.stringify(payload);
+    }
+    const resp = await (0, fetch_1.fetch)(url, opts);
+    if (resp.ok) {
+        return resp.data;
+    }
+    throw resp;
+}
+exports.k8sExec = k8sExec;

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":""}

package/dist/fluent/utils.test.js

@@ -0,0 +1,88 @@
+"use strict";
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: 2023-Present The Pepr Authors
+Object.defineProperty(exports, "__esModule", { value: true });
+const globals_1 = require("@jest/globals");
+const fetch_1 = require("../fetch");
+const upstream_1 = require("../upstream");
+const utils_1 = require("./utils");
+globals_1.jest.mock("https");
+globals_1.jest.mock("../fetch");
+(0, globals_1.describe)("pathBuilder Function", () => {
+    const serverUrl = "https://jest-test:8080";
+    (0, globals_1.it)("should throw an error if the kind is not specified and the model is not a KubernetesObject", () => {
+        const model = { name: "Unknown" };
+        const filters = {};
+        (0, globals_1.expect)(() => (0, utils_1.pathBuilder)("", model, filters)).toThrow("Kind not specified for Unknown");
+    });
+    (0, globals_1.it)("should generate a path for core group kinds", () => {
+        const filters = { namespace: "default", name: "mypod" };
+        const result = (0, utils_1.pathBuilder)(serverUrl, upstream_1.Pod, filters);
+        const expected = new URL("/api/v1/namespaces/default/pods/mypod", serverUrl);
+        (0, globals_1.expect)(result).toEqual(expected);
+    });
+    (0, globals_1.it)("should generate a path for non-core group kinds", () => {
+        const filters = {
+            namespace: "default",
+            name: "myingress",
+        };
+        const result = (0, utils_1.pathBuilder)(serverUrl, upstream_1.Ingress, filters);
+        const expected = new URL("/apis/networking.k8s.io/v1/namespaces/default/ingresses/myingress", serverUrl);
+        (0, globals_1.expect)(result).toEqual(expected);
+    });
+    (0, globals_1.it)("should generate a path without a namespace if not provided", () => {
+        const filters = { name: "tester" };
+        const result = (0, utils_1.pathBuilder)(serverUrl, upstream_1.ClusterRole, filters);
+        const expected = new URL("/apis/rbac.authorization.k8s.io/v1/clusterroles/tester", serverUrl);
+        (0, globals_1.expect)(result).toEqual(expected);
+    });
+    (0, globals_1.it)("should generate a path without a name if excludeName is true", () => {
+        const filters = { namespace: "default", name: "mypod" };
+        const result = (0, utils_1.pathBuilder)(serverUrl, upstream_1.Pod, filters, true);
+        const expected = new URL("/api/v1/namespaces/default/pods", serverUrl);
+        (0, globals_1.expect)(result).toEqual(expected);
+    });
+});
+(0, globals_1.describe)("kubeExec Function", () => {
+    const mockedFetch = globals_1.jest.mocked(fetch_1.fetch);
+    const fakeFilters = { name: "fake", namespace: "default" };
+    const fakeMethod = "GET";
+    const fakePayload = { metadata: { name: "fake", namespace: "default" } };
+    const fakeUrl = new URL("http://jest-test:8080/api/v1/namespaces/default/pods/fake");
+    const fakeOpts = {
+        body: JSON.stringify(fakePayload),
+        headers: {
+            "Content-Type": "application/json",
+            "User-Agent": `kubernetes-fluent-client`,
+        },
+        method: fakeMethod,
+    };
+    (0, globals_1.beforeEach)(() => {
+        mockedFetch.mockClear();
+    });
+    (0, globals_1.it)("should make a successful fetch call", async () => {
+        mockedFetch.mockResolvedValueOnce({
+            ok: true,
+            data: fakePayload,
+            status: 200,
+            statusText: "OK",
+        });
+        const result = await (0, utils_1.k8sExec)(upstream_1.Pod, fakeFilters, fakeMethod, fakePayload);
+        (0, globals_1.expect)(result).toEqual(fakePayload);
+        (0, globals_1.expect)(mockedFetch).toHaveBeenCalledWith(fakeUrl, globals_1.expect.objectContaining(fakeOpts));
+    });
+    (0, globals_1.it)("should handle fetch call failure", async () => {
+        const fakeStatus = 404;
+        const fakeStatusText = "Not Found";
+        mockedFetch.mockResolvedValueOnce({
+            ok: false,
+            data: null,
+            status: fakeStatus,
+            statusText: fakeStatusText,
+        });
+        await (0, globals_1.expect)((0, utils_1.k8sExec)(upstream_1.Pod, fakeFilters, fakeMethod, fakePayload)).rejects.toEqual(globals_1.expect.objectContaining({
+            status: fakeStatus,
+            statusText: fakeStatusText,
+        }));
+    });
+});

package/dist/fluent/watch.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="node" />
+import { GenericClass } from "../types";
+import { Filters, WatchAction } from "./types";
+/**
+ * Execute a watch on the specified resource.
+ */
+export declare function ExecWatch<T extends GenericClass>(model: T, filters: Filters, callback: WatchAction<T>): Promise<AbortController>;
+//# sourceMappingURL=watch.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"watch.d.ts","sourceRoot":"","sources":["../../src/fluent/watch.ts"],"names":[],"mappings":";AAMA,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AACxC,OAAO,EAAE,OAAO,EAAE,WAAW,EAAc,MAAM,SAAS,CAAC;AAG3D;;GAEG;AACH,wBAAsB,SAAS,CAAC,CAAC,SAAS,YAAY,EACpD,KAAK,EAAE,CAAC,EACR,OAAO,EAAE,OAAO,EAChB,QAAQ,EAAE,WAAW,CAAC,CAAC,CAAC,4BA6EzB"}

package/dist/fluent/watch.js

@@ -0,0 +1,78 @@
+"use strict";
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: 2023-Present The Pepr Authors
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExecWatch = void 0;
+const readline_1 = __importDefault(require("readline"));
+const node_fetch_1 = __importDefault(require("node-fetch"));
+const utils_1 = require("./utils");
+/**
+ * Execute a watch on the specified resource.
+ */
+async function ExecWatch(model, filters, callback) {
+    // 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}`);
+    }
+    // Add abort controller to the long-running request
+    const controller = new AbortController();
+    opts.signal = controller.signal;
+    // Close the connection and make the callback function no-op
+    let close = (err) => {
+        controller.abort();
+        close = () => { };
+        if (err) {
+            throw err;
+        }
+    };
+    try {
+        // Make the actual request
+        const response = await (0, node_fetch_1.default)(url, opts);
+        // If the request is successful, start listening for events
+        if (response.ok) {
+            const { body } = response;
+            // Bind connection events to the close function
+            body.on("error", close);
+            body.on("close", close);
+            body.on("finish", close);
+            // Create a readline interface to parse the stream
+            const rl = readline_1.default.createInterface({
+                input: response.body,
+                terminal: false,
+            });
+            // Listen for events and call the callback function
+            rl.on("line", 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);
+                }
+                catch (ignore) {
+                    // ignore parse errors
+                }
+            });
+        }
+        else {
+            // If the request fails, throw an error
+            const error = new Error(response.statusText);
+            error.statusCode = response.status;
+            throw error;
+        }
+    }
+    catch (e) {
+        close(e);
+    }
+    return controller;
+}
+exports.ExecWatch = ExecWatch;

package/dist/index.d.ts

@@ -1 +1,8 @@
+import * as kind from "./upstream";
+/** kind is a collection of K8s types to be used within a K8s call: `K8s(kind.Secret).Apply({})`. */
+export { kind };
+export { fetch } from "./fetch";
+export { K8s } from "./fluent";
+export { RegisterKind, modelToGroupVersionKind } from "./kinds";
+export * from "./types";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":""}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,IAAI,MAAM,YAAY,CAAC;AAEnC,oGAAoG;AACpG,OAAO,EAAE,IAAI,EAAE,CAAC;AAGhB,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAGhC,OAAO,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAG/B,OAAO,EAAE,YAAY,EAAE,uBAAuB,EAAE,MAAM,SAAS,CAAC;AAEhE,cAAc,SAAS,CAAC"}

package/dist/index.js

@@ -1,2 +1,45 @@
 "use strict";
-console.log("Hello, world!");
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: 2023-Present The Kubernetes Fluent Client Authors
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.modelToGroupVersionKind = exports.RegisterKind = exports.K8s = exports.fetch = exports.kind = void 0;
+// Export kinds as a single object
+const kind = __importStar(require("./upstream"));
+exports.kind = kind;
+// Export the node-fetch wrapper
+var fetch_1 = require("./fetch");
+Object.defineProperty(exports, "fetch", { enumerable: true, get: function () { return fetch_1.fetch; } });
+// Export the fluent API entrypoint
+var fluent_1 = require("./fluent");
+Object.defineProperty(exports, "K8s", { enumerable: true, get: function () { return fluent_1.K8s; } });
+// Export helpers for working with K8s types
+var kinds_1 = require("./kinds");
+Object.defineProperty(exports, "RegisterKind", { enumerable: true, get: function () { return kinds_1.RegisterKind; } });
+Object.defineProperty(exports, "modelToGroupVersionKind", { enumerable: true, get: function () { return kinds_1.modelToGroupVersionKind; } });
+__exportStar(require("./types"), exports);

package/dist/kinds.d.ts

@@ -0,0 +1,10 @@
+import { GenericClass, GroupVersionKind } from "./types";
+export declare function modelToGroupVersionKind(key: string): GroupVersionKind;
+/**
+ * Registers a new model and GroupVersionKind to be used within the fluent API.
+ *
+ * @param model Used to match the GroupVersionKind and define the type-data for the request
+ * @param groupVersionKind Contains the match parameters to determine the request should be handled
+ */
+export declare const RegisterKind: (model: GenericClass, groupVersionKind: GroupVersionKind) => void;
+//# sourceMappingURL=kinds.d.ts.map

package/dist/kinds.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kinds.d.ts","sourceRoot":"","sources":["../src/kinds.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AA0fzD,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,MAAM,GAAG,gBAAgB,CAErE;AAED;;;;;GAKG;AACH,eAAO,MAAM,YAAY,UAAW,YAAY,oBAAoB,gBAAgB,SAUnF,CAAC"}