fix: support YAML 1.1 parsing in Kubernetes manifests by replacing js-yaml with yaml

package.json

@@ -62,15 +62,15 @@
         "form-data": "^4.0.0",
         "hpagent": "^1.2.0",
         "isomorphic-ws": "^5.0.0",
-        "js-yaml": "^4.1.0",
         "jsonpath-plus": "^10.3.0",
         "node-fetch": "^2.6.9",
         "openid-client": "^6.1.3",
         "rfc4648": "^1.3.0",
         "socks-proxy-agent": "^8.0.4",
         "stream-buffers": "^3.0.2",
         "tar-fs": "^3.0.9",
-        "ws": "^8.18.2"
+        "ws": "^8.18.2",
+        "yaml": "^2.8.0"
     },
     "devDependencies": {
         "@eslint/js": "^9.18.0",

src/yaml.ts

@@ -1,4 +1,4 @@
-import yaml from 'js-yaml';
+import YAML from 'yaml';
 import { getSerializationType } from './util.js';
 import { KubernetesObject } from './types.js';
 import { ObjectSerializer } from './serializer.js';
@@ -9,13 +9,12 @@ import { ObjectSerializer } from './serializer.js';
  * @param opts - Optional YAML load options.
  * @returns The deserialized Kubernetes object.
  */
-export function loadYaml<T>(data: string, opts?: yaml.LoadOptions): T {
-    const yml = yaml.load(data, opts) as any as KubernetesObject;
+export function loadYaml<T>(data: string): T {
+    const yml = YAML.parse(data, { version: '1.1' }) as any as KubernetesObject;
     if (!yml) {
         throw new Error('Failed to load YAML');
     }
     const type = getSerializationType(yml.apiVersion, yml.kind);
-
     return ObjectSerializer.deserialize(yml, type) as T;
 }
 
@@ -25,12 +24,12 @@ export function loadYaml<T>(data: string, opts?: yaml.LoadOptions): T {
  * @param opts - Optional YAML load options.
  * @returns An array of deserialized Kubernetes objects.
  */
-export function loadAllYaml(data: string, opts?: yaml.LoadOptions): any[] {
-    const ymls = yaml.loadAll(data, undefined, opts);
-    return ymls.map((yml) => {
-        const obj = yml as KubernetesObject;
+export function loadAllYaml(data: string): any[] {
+    const ymls = YAML.parseAllDocuments(data, { version: '1.1' });
+    return ymls.map((doc) => {
+        const obj = doc.toJS() as KubernetesObject;
         const type = getSerializationType(obj.apiVersion, obj.kind);
-        return ObjectSerializer.deserialize(yml, type);
+        return ObjectSerializer.deserialize(obj, type);
     });
 }
 
@@ -40,9 +39,9 @@ export function loadAllYaml(data: string, opts?: yaml.LoadOptions): any[] {
  * @param opts - Optional YAML dump options.
  * @returns The YAML string representation of the serialized Kubernetes object.
  */
-export function dumpYaml(object: any, opts?: yaml.DumpOptions): string {
+export function dumpYaml(object: any): string {
     const kubeObject = object as KubernetesObject;
     const type = getSerializationType(kubeObject.apiVersion, kubeObject.kind);
     const serialized = ObjectSerializer.serialize(kubeObject, type);
-    return yaml.dump(serialized, opts);
+    return YAML.stringify(serialized);
 }

src/yaml_test.ts

@@ -154,4 +154,39 @@ spec:
         // not using strict equality as types are not matching
         deepEqual(actual, expected);
     });
+
+    it('should parse octal-like strings as numbers (YAML 1.1 style)', () => {
+        const yaml = `
+    defaultMode: 0644
+    fileMode: 0755
+    `;
+        const result = loadYaml<{
+            defaultMode: number;
+            fileMode: number;
+        }>(yaml);
+
+        // 0644 (octal) = 420 decimal, 0755 = 493
+        strictEqual(result.defaultMode, 420);
+        strictEqual(result.fileMode, 493);
+    });
+
+    it('should parse boolean-like strings as booleans (YAML 1.1 style)', () => {
+        const yaml = `
+    enableFeature: yes
+    debugMode: ON
+    maintenance: no
+    safeMode: off
+    `;
+        const result = loadYaml<{
+            enableFeature: boolean;
+            debugMode: boolean;
+            maintenance: boolean;
+            safeMode: boolean;
+        }>(yaml);
+
+        strictEqual(result.enableFeature, true);
+        strictEqual(result.debugMode, true);
+        strictEqual(result.maintenance, false);
+        strictEqual(result.safeMode, false);
+    });
 });