@intentius/chant-lexicon-k8s 0.0.13 → 0.0.15

package/src/serializer.test.ts

@@ -143,6 +143,76 @@ describe("k8sSerializer", () => {
     expect(result).not.toContain("spec:");
   });
 
+  test("ClusterRole is specless type", () => {
+    const entities = new Map<string, any>();
+    entities.set(
+      "viewRole",
+      mockResource("K8s::Rbac::ClusterRole", {
+        metadata: { name: "view-role" },
+        rules: [{ apiGroups: [""], resources: ["pods"], verbs: ["get", "list"] }],
+      }),
+    );
+
+    const result = k8sSerializer.serialize(entities);
+    expect(result).toContain("kind: ClusterRole");
+    expect(result).toContain("name: view-role");
+    expect(result).not.toContain("spec:");
+  });
+
+  test("ClusterRoleBinding is specless type", () => {
+    const entities = new Map<string, any>();
+    entities.set(
+      "viewBinding",
+      mockResource("K8s::Rbac::ClusterRoleBinding", {
+        metadata: { name: "view-binding" },
+        roleRef: { apiGroup: "rbac.authorization.k8s.io", kind: "ClusterRole", name: "view-role" },
+        subjects: [{ kind: "ServiceAccount", name: "default", namespace: "default" }],
+      }),
+    );
+
+    const result = k8sSerializer.serialize(entities);
+    expect(result).toContain("kind: ClusterRoleBinding");
+    expect(result).not.toContain("spec:");
+  });
+
+  test("StorageClass is specless type", () => {
+    const entities = new Map<string, any>();
+    entities.set(
+      "gp3",
+      mockResource("K8s::Storage::StorageClass", {
+        metadata: { name: "gp3-encrypted" },
+        provisioner: "ebs.csi.aws.com",
+        parameters: { type: "gp3", encrypted: "true" },
+        reclaimPolicy: "Delete",
+        volumeBindingMode: "WaitForFirstConsumer",
+      }),
+    );
+
+    const result = k8sSerializer.serialize(entities);
+    expect(result).toContain("kind: StorageClass");
+    expect(result).toContain("provisioner: ebs.csi.aws.com");
+    expect(result).not.toContain("spec:");
+  });
+
+  test("APIService is specless type", () => {
+    const entities = new Map<string, any>();
+    entities.set(
+      "metricsApi",
+      mockResource("K8s::Admissionregistration::APIService", {
+        metadata: { name: "v1beta1.metrics.k8s.io" },
+        group: "metrics.k8s.io",
+        version: "v1beta1",
+        service: { name: "metrics-server", namespace: "kube-system" },
+        groupPriorityMinimum: 100,
+        versionPriority: 100,
+      }),
+    );
+
+    const result = k8sSerializer.serialize(entities);
+    expect(result).toContain("kind: APIService");
+    expect(result).not.toContain("spec:");
+  });
+
   test("multi-resource entities joined by ---", () => {
     const entities = new Map<string, any>();
     entities.set(
@@ -248,6 +318,56 @@ describe("k8sSerializer", () => {
     expect(result).toBe("");
   });
 
+  test("Namespaces appear before other resources regardless of insertion order", () => {
+    const entities = new Map<string, any>();
+    // Insert Deployment first, then Namespace — Namespace should still come first in output
+    entities.set(
+      "deploy",
+      mockResource("K8s::Apps::Deployment", {
+        metadata: { name: "app", namespace: "my-ns" },
+        spec: { replicas: 1 },
+      }),
+    );
+    entities.set(
+      "ns",
+      mockResource("K8s::Core::Namespace", {
+        metadata: { name: "my-ns" },
+      }),
+    );
+
+    const result = k8sSerializer.serialize(entities);
+    const docs = result.split("---");
+    // First document should be the Namespace
+    expect(docs[0]).toContain("kind: Namespace");
+    expect(docs[0]).toContain("name: my-ns");
+    // Second document should be the Deployment
+    expect(docs[1]).toContain("kind: Deployment");
+  });
+
+  test("ConfigMap multiline data emits as | block scalar", () => {
+    const entities = new Map<string, any>();
+    const multilineConfig = "[SERVICE]\n    Flush 5\n    Log_Level info\n\n[INPUT]\n    Name tail\n";
+    entities.set(
+      "config",
+      mockResource("K8s::Core::ConfigMap", {
+        metadata: { name: "app-config" },
+        data: { "fluent-bit.conf": multilineConfig },
+      }),
+    );
+
+    const result = k8sSerializer.serialize(entities);
+    expect(result).toContain("kind: ConfigMap");
+    // Must use | block scalar, not flatten to single line
+    expect(result).toContain("fluent-bit.conf: |");
+    // Content lines should be preserved (indented under the key)
+    expect(result).toContain("[SERVICE]");
+    expect(result).toContain("Flush 5");
+    expect(result).toContain("[INPUT]");
+    expect(result).toContain("Name tail");
+    // Should NOT contain literal \n in the output
+    expect(result).not.toContain("\\n");
+  });
+
   test("key ordering: apiVersion, kind, metadata, spec, then rest", () => {
     const entities = new Map<string, any>();
     entities.set(

package/src/serializer.ts

@@ -26,6 +26,13 @@ const SPECLESS_TYPES = new Set([
   "Secret",
   "Namespace",
   "ServiceAccount",
+  "ClusterRole",
+  "ClusterRoleBinding",
+  "Role",
+  "RoleBinding",
+  "StorageClass",
+  "PersistentVolume",
+  "APIService",
 ]);
 
 /**
@@ -157,7 +164,8 @@ export const k8sSerializer: Serializer = {
       }
     }
 
-    const documents: string[] = [];
+    const namespaceDocs: string[] = [];
+    const otherDocs: string[] = [];
 
     for (const [name, entity] of entities) {
       if (isPropertyDeclarable(entity)) continue;
@@ -230,12 +238,16 @@ export const k8sSerializer: Serializer = {
         }
       }
 
-      // Emit as YAML
+      // Emit as YAML — sort Namespaces first so kubectl apply succeeds
       const yamlDoc = emitK8sManifest(manifest);
-      documents.push(yamlDoc);
+      if (gvk.kind === "Namespace") {
+        namespaceDocs.push(yamlDoc);
+      } else {
+        otherDocs.push(yamlDoc);
+      }
     }
 
-    return documents.join("\n---\n");
+    return [...namespaceDocs, ...otherDocs].join("\n---\n");
   },
 };