kubernetes-fluent-client 0.0.0-development → 1.0.0

package/dist/upstream.d.ts

@@ -0,0 +1,4 @@
+/** a is a collection of K8s types to be used within an action: `When(a.Configmap)` */
+export { CoreV1Event as Event, V1APIService as APIService, V1CertificateSigningRequest as CertificateSigningRequest, V1ClusterRole as ClusterRole, V1ClusterRoleBinding as ClusterRoleBinding, V1ConfigMap as ConfigMap, V1ControllerRevision as ControllerRevision, V1CronJob as CronJob, V1CSIDriver as CSIDriver, V1CustomResourceDefinition as CustomResourceDefinition, V1DaemonSet as DaemonSet, V1Deployment as Deployment, V1EndpointSlice as EndpointSlice, V1HorizontalPodAutoscaler as HorizontalPodAutoscaler, V1Ingress as Ingress, V1IngressClass as IngressClass, V1Job as Job, V1LimitRange as LimitRange, V1LocalSubjectAccessReview as LocalSubjectAccessReview, V1MutatingWebhookConfiguration as MutatingWebhookConfiguration, V1Namespace as Namespace, V1NetworkPolicy as NetworkPolicy, V1Node as Node, V1PersistentVolume as PersistentVolume, V1PersistentVolumeClaim as PersistentVolumeClaim, V1Pod as Pod, V1PodDisruptionBudget as PodDisruptionBudget, V1PodTemplate as PodTemplate, V1ReplicaSet as ReplicaSet, V1ReplicationController as ReplicationController, V1ResourceQuota as ResourceQuota, V1Role as Role, V1RoleBinding as RoleBinding, V1RuntimeClass as RuntimeClass, V1Secret as Secret, V1SelfSubjectAccessReview as SelfSubjectAccessReview, V1SelfSubjectRulesReview as SelfSubjectRulesReview, V1Service as Service, V1ServiceAccount as ServiceAccount, V1StatefulSet as StatefulSet, V1StorageClass as StorageClass, V1SubjectAccessReview as SubjectAccessReview, V1TokenReview as TokenReview, V1ValidatingWebhookConfiguration as ValidatingWebhookConfiguration, V1VolumeAttachment as VolumeAttachment, } from "@kubernetes/client-node";
+export { GenericKind } from "./types";
+//# sourceMappingURL=upstream.d.ts.map

package/dist/upstream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"upstream.d.ts","sourceRoot":"","sources":["../src/upstream.ts"],"names":[],"mappings":"AAGA,sFAAsF;AACtF,OAAO,EACL,WAAW,IAAI,KAAK,EACpB,YAAY,IAAI,UAAU,EAC1B,2BAA2B,IAAI,yBAAyB,EACxD,aAAa,IAAI,WAAW,EAC5B,oBAAoB,IAAI,kBAAkB,EAC1C,WAAW,IAAI,SAAS,EACxB,oBAAoB,IAAI,kBAAkB,EAC1C,SAAS,IAAI,OAAO,EACpB,WAAW,IAAI,SAAS,EACxB,0BAA0B,IAAI,wBAAwB,EACtD,WAAW,IAAI,SAAS,EACxB,YAAY,IAAI,UAAU,EAC1B,eAAe,IAAI,aAAa,EAChC,yBAAyB,IAAI,uBAAuB,EACpD,SAAS,IAAI,OAAO,EACpB,cAAc,IAAI,YAAY,EAC9B,KAAK,IAAI,GAAG,EACZ,YAAY,IAAI,UAAU,EAC1B,0BAA0B,IAAI,wBAAwB,EACtD,8BAA8B,IAAI,4BAA4B,EAC9D,WAAW,IAAI,SAAS,EACxB,eAAe,IAAI,aAAa,EAChC,MAAM,IAAI,IAAI,EACd,kBAAkB,IAAI,gBAAgB,EACtC,uBAAuB,IAAI,qBAAqB,EAChD,KAAK,IAAI,GAAG,EACZ,qBAAqB,IAAI,mBAAmB,EAC5C,aAAa,IAAI,WAAW,EAC5B,YAAY,IAAI,UAAU,EAC1B,uBAAuB,IAAI,qBAAqB,EAChD,eAAe,IAAI,aAAa,EAChC,MAAM,IAAI,IAAI,EACd,aAAa,IAAI,WAAW,EAC5B,cAAc,IAAI,YAAY,EAC9B,QAAQ,IAAI,MAAM,EAClB,yBAAyB,IAAI,uBAAuB,EACpD,wBAAwB,IAAI,sBAAsB,EAClD,SAAS,IAAI,OAAO,EACpB,gBAAgB,IAAI,cAAc,EAClC,aAAa,IAAI,WAAW,EAC5B,cAAc,IAAI,YAAY,EAC9B,qBAAqB,IAAI,mBAAmB,EAC5C,aAAa,IAAI,WAAW,EAC5B,gCAAgC,IAAI,8BAA8B,EAClE,kBAAkB,IAAI,gBAAgB,GACvC,MAAM,yBAAyB,CAAC;AAEjC,OAAO,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC"}

package/dist/upstream.js

@@ -0,0 +1,54 @@
+"use strict";
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: 2023-Present The Kubernetes Fluent Client Authors
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GenericKind = exports.VolumeAttachment = exports.ValidatingWebhookConfiguration = exports.TokenReview = exports.SubjectAccessReview = exports.StorageClass = exports.StatefulSet = exports.ServiceAccount = exports.Service = exports.SelfSubjectRulesReview = exports.SelfSubjectAccessReview = exports.Secret = exports.RuntimeClass = exports.RoleBinding = exports.Role = exports.ResourceQuota = exports.ReplicationController = exports.ReplicaSet = exports.PodTemplate = exports.PodDisruptionBudget = exports.Pod = exports.PersistentVolumeClaim = exports.PersistentVolume = exports.Node = exports.NetworkPolicy = exports.Namespace = exports.MutatingWebhookConfiguration = exports.LocalSubjectAccessReview = exports.LimitRange = exports.Job = exports.IngressClass = exports.Ingress = exports.HorizontalPodAutoscaler = exports.EndpointSlice = exports.Deployment = exports.DaemonSet = exports.CustomResourceDefinition = exports.CSIDriver = exports.CronJob = exports.ControllerRevision = exports.ConfigMap = exports.ClusterRoleBinding = exports.ClusterRole = exports.CertificateSigningRequest = exports.APIService = exports.Event = void 0;
+/** a is a collection of K8s types to be used within an action: `When(a.Configmap)` */
+var client_node_1 = require("@kubernetes/client-node");
+Object.defineProperty(exports, "Event", { enumerable: true, get: function () { return client_node_1.CoreV1Event; } });
+Object.defineProperty(exports, "APIService", { enumerable: true, get: function () { return client_node_1.V1APIService; } });
+Object.defineProperty(exports, "CertificateSigningRequest", { enumerable: true, get: function () { return client_node_1.V1CertificateSigningRequest; } });
+Object.defineProperty(exports, "ClusterRole", { enumerable: true, get: function () { return client_node_1.V1ClusterRole; } });
+Object.defineProperty(exports, "ClusterRoleBinding", { enumerable: true, get: function () { return client_node_1.V1ClusterRoleBinding; } });
+Object.defineProperty(exports, "ConfigMap", { enumerable: true, get: function () { return client_node_1.V1ConfigMap; } });
+Object.defineProperty(exports, "ControllerRevision", { enumerable: true, get: function () { return client_node_1.V1ControllerRevision; } });
+Object.defineProperty(exports, "CronJob", { enumerable: true, get: function () { return client_node_1.V1CronJob; } });
+Object.defineProperty(exports, "CSIDriver", { enumerable: true, get: function () { return client_node_1.V1CSIDriver; } });
+Object.defineProperty(exports, "CustomResourceDefinition", { enumerable: true, get: function () { return client_node_1.V1CustomResourceDefinition; } });
+Object.defineProperty(exports, "DaemonSet", { enumerable: true, get: function () { return client_node_1.V1DaemonSet; } });
+Object.defineProperty(exports, "Deployment", { enumerable: true, get: function () { return client_node_1.V1Deployment; } });
+Object.defineProperty(exports, "EndpointSlice", { enumerable: true, get: function () { return client_node_1.V1EndpointSlice; } });
+Object.defineProperty(exports, "HorizontalPodAutoscaler", { enumerable: true, get: function () { return client_node_1.V1HorizontalPodAutoscaler; } });
+Object.defineProperty(exports, "Ingress", { enumerable: true, get: function () { return client_node_1.V1Ingress; } });
+Object.defineProperty(exports, "IngressClass", { enumerable: true, get: function () { return client_node_1.V1IngressClass; } });
+Object.defineProperty(exports, "Job", { enumerable: true, get: function () { return client_node_1.V1Job; } });
+Object.defineProperty(exports, "LimitRange", { enumerable: true, get: function () { return client_node_1.V1LimitRange; } });
+Object.defineProperty(exports, "LocalSubjectAccessReview", { enumerable: true, get: function () { return client_node_1.V1LocalSubjectAccessReview; } });
+Object.defineProperty(exports, "MutatingWebhookConfiguration", { enumerable: true, get: function () { return client_node_1.V1MutatingWebhookConfiguration; } });
+Object.defineProperty(exports, "Namespace", { enumerable: true, get: function () { return client_node_1.V1Namespace; } });
+Object.defineProperty(exports, "NetworkPolicy", { enumerable: true, get: function () { return client_node_1.V1NetworkPolicy; } });
+Object.defineProperty(exports, "Node", { enumerable: true, get: function () { return client_node_1.V1Node; } });
+Object.defineProperty(exports, "PersistentVolume", { enumerable: true, get: function () { return client_node_1.V1PersistentVolume; } });
+Object.defineProperty(exports, "PersistentVolumeClaim", { enumerable: true, get: function () { return client_node_1.V1PersistentVolumeClaim; } });
+Object.defineProperty(exports, "Pod", { enumerable: true, get: function () { return client_node_1.V1Pod; } });
+Object.defineProperty(exports, "PodDisruptionBudget", { enumerable: true, get: function () { return client_node_1.V1PodDisruptionBudget; } });
+Object.defineProperty(exports, "PodTemplate", { enumerable: true, get: function () { return client_node_1.V1PodTemplate; } });
+Object.defineProperty(exports, "ReplicaSet", { enumerable: true, get: function () { return client_node_1.V1ReplicaSet; } });
+Object.defineProperty(exports, "ReplicationController", { enumerable: true, get: function () { return client_node_1.V1ReplicationController; } });
+Object.defineProperty(exports, "ResourceQuota", { enumerable: true, get: function () { return client_node_1.V1ResourceQuota; } });
+Object.defineProperty(exports, "Role", { enumerable: true, get: function () { return client_node_1.V1Role; } });
+Object.defineProperty(exports, "RoleBinding", { enumerable: true, get: function () { return client_node_1.V1RoleBinding; } });
+Object.defineProperty(exports, "RuntimeClass", { enumerable: true, get: function () { return client_node_1.V1RuntimeClass; } });
+Object.defineProperty(exports, "Secret", { enumerable: true, get: function () { return client_node_1.V1Secret; } });
+Object.defineProperty(exports, "SelfSubjectAccessReview", { enumerable: true, get: function () { return client_node_1.V1SelfSubjectAccessReview; } });
+Object.defineProperty(exports, "SelfSubjectRulesReview", { enumerable: true, get: function () { return client_node_1.V1SelfSubjectRulesReview; } });
+Object.defineProperty(exports, "Service", { enumerable: true, get: function () { return client_node_1.V1Service; } });
+Object.defineProperty(exports, "ServiceAccount", { enumerable: true, get: function () { return client_node_1.V1ServiceAccount; } });
+Object.defineProperty(exports, "StatefulSet", { enumerable: true, get: function () { return client_node_1.V1StatefulSet; } });
+Object.defineProperty(exports, "StorageClass", { enumerable: true, get: function () { return client_node_1.V1StorageClass; } });
+Object.defineProperty(exports, "SubjectAccessReview", { enumerable: true, get: function () { return client_node_1.V1SubjectAccessReview; } });
+Object.defineProperty(exports, "TokenReview", { enumerable: true, get: function () { return client_node_1.V1TokenReview; } });
+Object.defineProperty(exports, "ValidatingWebhookConfiguration", { enumerable: true, get: function () { return client_node_1.V1ValidatingWebhookConfiguration; } });
+Object.defineProperty(exports, "VolumeAttachment", { enumerable: true, get: function () { return client_node_1.V1VolumeAttachment; } });
+var types_1 = require("./types");
+Object.defineProperty(exports, "GenericKind", { enumerable: true, get: function () { return types_1.GenericKind; } });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kubernetes-fluent-client",
-  "version": "0.0.0-development",
+  "version": "1.0.0",
   "description": "A @kubernetes/client-node fluent API wrapper that leverages K8s Server Side Apply",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -10,9 +10,12 @@
     "semantic-release": "semantic-release",
     "test": "jest src --coverage"
   },
+  "engines": {
+    "node": ">=18.0.0"
+  },
   "repository": {
     "type": "git",
-    "url": "https://github.com/defenseunicorns/kubernetes-fluent-client.git"
+    "url": "git+https://github.com/defenseunicorns/kubernetes-fluent-client.git"
   },
   "keywords": [
     "kubernetes",
@@ -29,16 +32,26 @@
   },
   "homepage": "https://github.com/defenseunicorns/kubernetes-fluent-client#readme",
   "dependencies": {
-    "@kubernetes/client-node": "1.0.0-rc3"
+    "@kubernetes/client-node": "1.0.0-rc3",
+    "fast-json-patch": "3.1.1",
+    "http-status-codes": "2.3.0",
+    "node-fetch": "2.7.0"
   },
   "devDependencies": {
     "@jest/globals": "29.7.0",
-    "@typescript-eslint/eslint-plugin": "6.5.0",
-    "@typescript-eslint/parser": "6.5.0",
+    "@typescript-eslint/eslint-plugin": "6.7.2",
+    "@typescript-eslint/parser": "6.7.2",
     "jest": "29.7.0",
+    "nock": "13.3.3",
     "prettier": "3.0.3",
-    "semantic-release": "22.0.1",
-    "typescript": "5.2.2",
-    "ts-jest": "29.1.1"
+    "semantic-release": "22.0.4",
+    "ts-jest": "29.1.1",
+    "typescript": "5.2.2"
+  },
+  "release": {
+    "branches": [
+      "main",
+      "next"
+    ]
   }
 }

package/src/fetch.test.ts

@@ -0,0 +1,115 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: 2023-Present The Pepr Authors
+
+import { expect, test, beforeEach } from "@jest/globals";
+
+import { StatusCodes } from "http-status-codes";
+import nock from "nock";
+import { RequestInit } from "node-fetch";
+import { fetch } from "./fetch";
+
+beforeEach(() => {
+  nock("https://jsonplaceholder.typicode.com")
+    .get("/todos/1")
+    .reply(200, {
+      userId: 1,
+      id: 1,
+      title: "Example title",
+      completed: false,
+    })
+    .post("/todos", {
+      title: "test todo",
+      userId: 1,
+      completed: false,
+    })
+    .reply(200, (uri, requestBody) => requestBody)
+    .get("/todos/empty-null")
+    .reply(200, undefined)
+    .get("/todos/empty-string")
+    .reply(200, "")
+    .get("/todos/empty-object")
+    .reply(200, {})
+    .get("/todos/invalid")
+    .replyWithError("Something bad happened");
+});
+
+test("fetch: should return without type data", async () => {
+  const url = "https://jsonplaceholder.typicode.com/todos/1";
+  const { data, ok } = await fetch<{ title: string }>(url);
+  expect(ok).toBe(true);
+  expect(data["title"]).toBe("Example title");
+});
+
+test("fetch: should return parsed JSON response as a specific type", async () => {
+  interface Todo {
+    userId: number;
+    id: number;
+    title: string;
+    completed: boolean;
+  }
+
+  const url = "https://jsonplaceholder.typicode.com/todos/1";
+  const { data, ok } = await fetch<Todo>(url);
+  expect(ok).toBe(true);
+  expect(data.id).toBe(1);
+  expect(typeof data.title).toBe("string");
+  expect(typeof data.completed).toBe("boolean");
+});
+
+test("fetch: should handle additional request options", async () => {
+  const url = "https://jsonplaceholder.typicode.com/todos";
+  const requestOptions: RequestInit = {
+    method: "POST",
+    body: JSON.stringify({
+      title: "test todo",
+      userId: 1,
+      completed: false,
+    }),
+    headers: {
+      "Content-type": "application/json; charset=UTF-8",
+    },
+  };
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const { data, ok } = await fetch<any>(url, requestOptions);
+  expect(ok).toBe(true);
+  expect(data["title"]).toBe("test todo");
+  expect(data["userId"]).toBe(1);
+  expect(data["completed"]).toBe(false);
+});
+
+test("fetch: should handle empty (null) responses", async () => {
+  const url = "https://jsonplaceholder.typicode.com/todos/empty-null";
+  const resp = await fetch(url);
+
+  expect(resp.data).toBe("");
+  expect(resp.ok).toBe(true);
+  expect(resp.status).toBe(StatusCodes.OK);
+});
+
+test("fetch: should handle empty (string) responses", async () => {
+  const url = "https://jsonplaceholder.typicode.com/todos/empty-string";
+  const resp = await fetch(url);
+
+  expect(resp.data).toBe("");
+  expect(resp.ok).toBe(true);
+  expect(resp.status).toBe(StatusCodes.OK);
+});
+
+test("fetch: should handle empty (object) responses", async () => {
+  const url = "https://jsonplaceholder.typicode.com/todos/empty-object";
+  const resp = await fetch(url);
+
+  expect(resp.data).toEqual({});
+  expect(resp.ok).toBe(true);
+  expect(resp.status).toBe(StatusCodes.OK);
+});
+
+test("fetch: should handle failed requests without throwing an error", async () => {
+  const url = "https://jsonplaceholder.typicode.com/todos/invalid";
+  const resp = await fetch(url);
+
+  expect(resp.data).toBe(undefined);
+  expect(resp.ok).toBe(false);
+  expect(resp.status).toBe(StatusCodes.BAD_REQUEST);
+});

package/src/fetch.ts

@@ -0,0 +1,72 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: 2023-Present The Pepr Authors
+
+import { StatusCodes } from "http-status-codes";
+import fetchRaw, { FetchError, RequestInfo, RequestInit } from "node-fetch";
+
+export type FetchResponse<T> = {
+  data: T;
+  ok: boolean;
+  status: number;
+  statusText: string;
+};
+
+/**
+ * Perform an async HTTP call and return the parsed JSON response, optionally
+ * as a specific type.
+ *
+ * @example
+ * ```ts
+ * fetch<string[]>("https://example.com/api/foo");
+ * ```
+ *
+ * @param url The URL or Request object to fetch
+ * @param init Additional options for the request
+ * @returns
+ */
+export async function fetch<T>(
+  url: URL | RequestInfo,
+  init?: RequestInit,
+): Promise<FetchResponse<T>> {
+  let data = undefined as unknown as T;
+  try {
+    const resp = await fetchRaw(url, init);
+    const contentType = resp.headers.get("content-type") || "";
+
+    if (resp.ok) {
+      // Parse the response as JSON if the content type is JSON
+      if (contentType.includes("application/json")) {
+        data = await resp.json();
+      } else {
+        // Otherwise, return however the response was read
+        data = (await resp.text()) as unknown as T;
+      }
+    }
+
+    return {
+      data,
+      ok: resp.ok,
+      status: resp.status,
+      statusText: resp.statusText,
+    };
+  } catch (e) {
+    if (e instanceof FetchError) {
+      // Parse the error code from the FetchError or default to 400 (Bad Request)
+      const status = parseInt(e.code || "400");
+
+      return {
+        data,
+        ok: false,
+        status,
+        statusText: e.message,
+      };
+    }
+
+    return {
+      data,
+      ok: false,
+      status: StatusCodes.BAD_REQUEST,
+      statusText: "Unknown error",
+    };
+  }
+}

package/src/fluent/kube.test.ts

@@ -0,0 +1,136 @@
+import { beforeEach, describe, expect, it, jest } from "@jest/globals";
+import { Operation } from "fast-json-patch";
+
+import { Pod } from "../upstream";
+import { Kube } from "./kube";
+import { kubeExec } from "./utils";
+
+// Setup mocks
+jest.mock("./utils");
+
+describe("Kube", () => {
+  const fakeResource = { metadata: { name: "fake", namespace: "default" } };
+  const mockedKubeExec = jest.mocked(kubeExec).mockResolvedValue(fakeResource);
+
+  beforeEach(() => {
+    // Clear all instances and calls to constructor and all methods:
+    mockedKubeExec.mockClear();
+  });
+
+  it("should create a resource", async () => {
+    const kube = Kube(Pod);
+    const result = await kube.Create(fakeResource);
+
+    expect(result).toEqual(fakeResource);
+    expect(mockedKubeExec).toHaveBeenCalledWith(
+      Pod,
+      expect.objectContaining({
+        name: "fake",
+        namespace: "default",
+      }),
+      "POST",
+      fakeResource,
+    );
+  });
+
+  it("should delete a resource", async () => {
+    const kube = Kube(Pod);
+    await kube.Delete(fakeResource);
+
+    expect(mockedKubeExec).toHaveBeenCalledWith(
+      Pod,
+      expect.objectContaining({
+        name: "fake",
+        namespace: "default",
+      }),
+      "DELETE",
+    );
+  });
+
+  it("should patch a resource", async () => {
+    const patchOperations: Operation[] = [
+      { op: "replace", path: "/metadata/name", value: "new-fake" },
+    ];
+
+    const kube = Kube(Pod);
+    const result = await kube.Patch(patchOperations);
+
+    expect(result).toEqual(fakeResource);
+    expect(mockedKubeExec).toHaveBeenCalledWith(Pod, {}, "PATCH", patchOperations);
+  });
+
+  it("should filter with WithField", async () => {
+    const kube = Kube(Pod).WithField("metadata.name", "fake");
+    await kube.Get();
+    expect(mockedKubeExec).toHaveBeenCalledWith(
+      Pod,
+      expect.objectContaining({
+        fields: {
+          "metadata.name": "fake",
+        },
+      }),
+      "GET",
+    );
+  });
+
+  it("should filter with WithLabel", async () => {
+    const kube = Kube(Pod).WithLabel("app", "fakeApp");
+    await kube.Get();
+    expect(mockedKubeExec).toHaveBeenCalledWith(
+      Pod,
+      expect.objectContaining({
+        labels: {
+          app: "fakeApp",
+        },
+      }),
+      "GET",
+    );
+  });
+
+  it("should use InNamespace", async () => {
+    const kube = Kube(Pod).InNamespace("fakeNamespace");
+    await kube.Get();
+    expect(mockedKubeExec).toHaveBeenCalledWith(
+      Pod,
+      expect.objectContaining({
+        namespace: "fakeNamespace",
+      }),
+      "GET",
+    );
+  });
+
+  it("should throw an error if namespace is already specified", async () => {
+    const kube = Kube(Pod, { namespace: "default" });
+    expect(() => kube.InNamespace("fakeNamespace")).toThrow("Namespace already specified: default");
+  });
+
+  it("should handle Delete when the resource doesn't exist", async () => {
+    mockedKubeExec.mockRejectedValueOnce({ status: 404 }); // Not Found on first call
+    const kube = Kube(Pod);
+    await expect(kube.Delete("fakeResource")).resolves.toBeUndefined();
+  });
+
+  it("should handle Get", async () => {
+    const kube = Kube(Pod);
+    const result = await kube.Get("fakeResource");
+
+    expect(result).toEqual(fakeResource);
+    expect(mockedKubeExec).toHaveBeenCalledWith(
+      Pod,
+      expect.objectContaining({
+        name: "fakeResource",
+      }),
+      "GET",
+    );
+  });
+
+  it("should thrown an error if Get is called with a name and filters are already specified a name", async () => {
+    const kube = Kube(Pod, { name: "fake" });
+    await expect(kube.Get("fakeResource")).rejects.toThrow("Name already specified: fake");
+  });
+
+  it("should throw an error if no patch operations provided", async () => {
+    const kube = Kube(Pod);
+    await expect(kube.Patch([])).rejects.toThrow("No operations specified");
+  });
+});

package/src/fluent/kube.ts

@@ -0,0 +1,126 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: 2023-Present The Pepr Authors
+
+import { KubernetesListObject, KubernetesObject } from "@kubernetes/client-node";
+import { Operation } from "fast-json-patch";
+import { StatusCodes } from "http-status-codes";
+
+import { modelToGroupVersionKind } from "../kinds";
+import { GenericClass } from "../types";
+import { Filters, KubeInit, Paths, WatchAction } from "./types";
+import { kubeExec } from "./utils";
+import { ExecWatch } from "./watch";
+
+/**
+ * Kubernetes fluent API inspired by Kubectl. Pass in a model, then call filters and actions on it.
+ *
+ * @param model - the model to use for the API
+ * @param filters - (optional) filter overrides, can also be chained
+ */
+export function Kube<T extends GenericClass, K extends KubernetesObject = InstanceType<T>>(
+  model: T,
+  filters: Filters = {},
+): KubeInit<K> {
+  const withFilters = { WithField, WithLabel, Get, Delete, Watch };
+  const matchedKind = filters.kindOverride || modelToGroupVersionKind(model.name);
+
+  function InNamespace(namespaces: string) {
+    if (filters.namespace) {
+      throw new Error(`Namespace already specified: ${filters.namespace}`);
+    }
+
+    filters.namespace = namespaces;
+    return withFilters;
+  }
+
+  function WithField<P extends Paths<K>>(key: P, value = "") {
+    filters.fields = filters.fields || {};
+    filters.fields[key] = value;
+    return withFilters;
+  }
+
+  function WithLabel(key: string, value = "") {
+    filters.labels = filters.labels || {};
+    filters.labels[key] = value;
+    return withFilters;
+  }
+
+  function syncFilters(payload: K) {
+    // Ensure the payload has metadata
+    payload.metadata = payload.metadata || {};
+
+    if (!filters.namespace) {
+      filters.namespace = payload.metadata.namespace;
+    }
+
+    if (!filters.name) {
+      filters.name = payload.metadata.name;
+    }
+
+    if (!payload.apiVersion) {
+      payload.apiVersion = [matchedKind.group, matchedKind.version].filter(Boolean).join("/");
+    }
+
+    if (!payload.kind) {
+      payload.kind = matchedKind.kind;
+    }
+  }
+
+  async function Get(): Promise<KubernetesListObject<K>>;
+  async function Get(name: string): Promise<K>;
+  async function Get(name?: string) {
+    if (name) {
+      if (filters.name) {
+        throw new Error(`Name already specified: ${filters.name}`);
+      }
+      filters.name = name;
+    }
+
+    return kubeExec<T, K | KubernetesListObject<K>>(model, filters, "GET");
+  }
+
+  async function Delete(filter?: K | string): Promise<void> {
+    if (typeof filter === "string") {
+      filters.name = filter;
+    } else if (filter) {
+      syncFilters(filter);
+    }
+
+    try {
+      // Try to delete the resource
+      await kubeExec<T, void>(model, filters, "DELETE");
+    } catch (e) {
+      // If the resource doesn't exist, ignore the error
+      if (e.status === StatusCodes.NOT_FOUND) {
+        return;
+      }
+
+      throw e;
+    }
+  }
+
+  async function Apply(resource: K): Promise<K> {
+    syncFilters(resource);
+    return kubeExec(model, filters, "APPLY", resource);
+  }
+
+  async function Create(resource: K): Promise<K> {
+    syncFilters(resource);
+    return kubeExec(model, filters, "POST", resource);
+  }
+
+  async function Patch(payload: Operation[]): Promise<K> {
+    // If there are no operations, throw an error
+    if (payload.length < 1) {
+      throw new Error("No operations specified");
+    }
+
+    return kubeExec<T, K>(model, filters, "PATCH", payload);
+  }
+
+  async function Watch(callback: WatchAction<T>): Promise<void> {
+    await ExecWatch(model, filters, callback);
+  }
+
+  return { InNamespace, Apply, Create, Patch, ...withFilters };
+}