@hiscojs/yaml-updater 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,905 @@
+# @hiscojs/yaml-updater
+
+Type-safe, immutable YAML updates with comment preservation, multi-document support, and advanced array merging strategies.
+
+Built on top of [@hiscojs/object-updater](https://www.npmjs.com/package/@hiscojs/object-updater) for powerful object manipulation capabilities.
+
+## Installation
+
+```bash
+npm install @hiscojs/yaml-updater
+```
+
+## Quick Start
+
+```typescript
+import { updateYaml } from '@hiscojs/yaml-updater';
+
+const yamlString = `
+apiVersion: v1
+kind: ConfigMap
+data:
+  database: localhost
+`;
+
+const { result } = updateYaml({
+  yamlString,
+  annotate: ({ change }) => {
+    change({
+      findKey: (parsed) => parsed.data,
+      merge: () => ({ database: 'db.production.com' })
+    });
+  }
+});
+
+console.log(result);
+// apiVersion: v1
+// kind: ConfigMap
+// data:
+//   database: db.production.com
+```
+
+## Features
+
+- **Type-Safe**: Full TypeScript support with generic type parameters
+- **Comment Preservation**: Automatically preserves existing YAML comments
+- **Comment Manipulation**: Add, remove, or update comments programmatically
+- **Multi-Document Support**: Handle YAML files with multiple documents
+- **Immutable**: Original YAML strings are never modified
+- **Advanced Array Merging**: Multiple strategies for merging arrays
+- **Proxy-Based Path Tracking**: Automatic path detection
+- **Formatting Preservation**: Maintains indentation and spacing
+
+## API Reference
+
+### `updateYaml<T>(options)`
+
+Updates a YAML string immutably with type safety and comment preservation.
+
+#### Parameters
+
+```typescript
+interface UpdateYamlOptions<T> {
+  yamlString: string;
+  selectDocument?: (yamlDocuments: Document[]) => number;
+  annotate?: (annotator: {
+    change: <L>(options: ChangeOptions<T, L>) => void;
+  }) => void;
+}
+```
+
+#### Returns
+
+```typescript
+interface YamlEdit<T> {
+  result: string;           // Updated YAML string
+  resultParsed: T;          // Parsed updated object
+  originalParsed: T;        // Original parsed object
+  comments: Array<{         // Comments that were added
+    path: (string | number)[];
+    comment: string;
+  }>;
+}
+```
+
+### `change<L>(options)`
+
+Defines a single change operation with optional commenting.
+
+```typescript
+interface ChangeOptions<T, L> {
+  findKey: (parsed: T) => L;
+  merge: (originalValue: L) => Partial<L>;
+  comment?: (previousComment?: string) => string | undefined;
+}
+```
+
+## Basic Usage
+
+### Simple Property Update
+
+```typescript
+const yamlString = `
+server:
+  host: localhost
+  port: 3000
+`;
+
+const { result } = updateYaml({
+  yamlString,
+  annotate: ({ change }) => {
+    change({
+      findKey: (parsed) => parsed.server,
+      merge: () => ({ port: 8080 })
+    });
+  }
+});
+
+// server:
+//   host: localhost
+//   port: 8080
+```
+
+### Type-Safe Updates
+
+```typescript
+interface Config {
+  server: {
+    host: string;
+    port: number;
+  };
+  database: {
+    host: string;
+    port: number;
+  };
+}
+
+const { result, resultParsed } = updateYaml<Config>({
+  yamlString,
+  annotate: ({ change }) => {
+    change({
+      findKey: (parsed) => parsed.server,  // Fully typed!
+      merge: () => ({ port: 8080 })
+    });
+  }
+});
+
+console.log(resultParsed.server.port);  // Type-safe access
+```
+
+## Comment Management
+
+### Adding Comments
+
+```typescript
+const { result } = updateYaml({
+  yamlString,
+  annotate: ({ change }) => {
+    change({
+      findKey: (parsed) => parsed.spec,
+      merge: () => ({ replicas: 3 }),
+      comment: () => 'Scaled to 3 replicas for high availability'
+    });
+  }
+});
+
+// spec:
+//   # Scaled to 3 replicas for high availability
+//   replicas: 3
+```
+
+### Dynamic Comments
+
+```typescript
+const { result } = updateYaml({
+  yamlString,
+  annotate: ({ change }) => {
+    change({
+      findKey: (parsed) => parsed.spec,
+      merge: (originalValue) => ({
+        replicas: originalValue.replicas * 2
+      }),
+      comment: (prevComment) =>
+        `Scaled from ${originalValue.replicas} to ${originalValue.replicas * 2}`
+    });
+  }
+});
+```
+
+### Using `addInstructions` for Comments
+
+```typescript
+import { updateYaml, addInstructions } from '@hiscojs/yaml-updater';
+
+const { result } = updateYaml({
+  yamlString,
+  annotate: ({ change }) => {
+    change({
+      findKey: (parsed) => parsed,
+      merge: () => ({
+        ...addInstructions({
+          prop: 'data',
+          comment: 'Configuration data section'
+        }),
+        data: {
+          key: 'value'
+        }
+      })
+    });
+  }
+});
+
+// # Configuration data section
+// data:
+//   key: value
+```
+
+### Removing Comments
+
+```typescript
+const { result } = updateYaml({
+  yamlString,
+  annotate: ({ change }) => {
+    change({
+      findKey: (parsed) => parsed,
+      merge: () => ({
+        ...addInstructions({
+          prop: 'data',
+          removeComment: true
+        }),
+        data: { key: 'value' }
+      })
+    });
+  }
+});
+```
+
+## Array Merging Strategies
+
+### `mergeByContents` - Deduplicate by Deep Equality
+
+```typescript
+const yamlString = `
+items:
+  - item1
+  - item2
+`;
+
+const { result } = updateYaml({
+  yamlString,
+  annotate: ({ change }) => {
+    change({
+      findKey: (parsed) => parsed,
+      merge: () => ({
+        ...addInstructions({
+          prop: 'items',
+          mergeByContents: true
+        }),
+        items: ['item2', 'item3']  // item2 deduplicated
+      })
+    });
+  }
+});
+
+// items:
+//   - item1
+//   - item2
+//   - item3
+```
+
+### `mergeByName` - Merge by Name Property
+
+```typescript
+const yamlString = `
+spec:
+  containers:
+    - name: app
+      image: myapp:1.0
+    - name: sidecar
+      image: sidecar:1.0
+`;
+
+interface Container {
+  name: string;
+  image: string;
+}
+
+interface PodSpec {
+  spec: {
+    containers: Container[];
+  };
+}
+
+const { result } = updateYaml<PodSpec>({
+  yamlString,
+  annotate: ({ change }) => {
+    change({
+      findKey: (parsed) => parsed.spec,
+      merge: () => ({
+        ...addInstructions({
+          prop: 'containers',
+          mergeByName: true
+        }),
+        containers: [
+          { name: 'app', image: 'myapp:2.0' }  // Updates 'app' container
+        ]
+      })
+    });
+  }
+});
+
+// spec:
+//   containers:
+//     - name: app
+//       image: myapp:2.0      # Updated
+//     - name: sidecar
+//       image: sidecar:1.0    # Preserved
+```
+
+### `mergeByProp` - Merge by Custom Property
+
+```typescript
+const yamlString = `
+services:
+  - serviceId: api
+    url: http://api.local
+  - serviceId: db
+    url: postgres://db.local
+`;
+
+const { result } = updateYaml({
+  yamlString,
+  annotate: ({ change }) => {
+    change({
+      findKey: (parsed) => parsed,
+      merge: () => ({
+        ...addInstructions({
+          prop: 'services',
+          mergeByProp: 'serviceId'
+        }),
+        services: [
+          { serviceId: 'api', url: 'https://api.prod' }
+        ]
+      })
+    });
+  }
+});
+```
+
+### `deepMerge` - Deep Merge Nested Objects
+
+```typescript
+const yamlString = `
+configs:
+  - name: database
+    settings:
+      timeout: 30
+      pool: 10
+      ssl: true
+`;
+
+const { result } = updateYaml({
+  yamlString,
+  annotate: ({ change }) => {
+    change({
+      findKey: (parsed) => parsed,
+      merge: () => ({
+        ...addInstructions({
+          prop: 'configs',
+          mergeByName: true,
+          deepMerge: true
+        }),
+        configs: [
+          {
+            name: 'database',
+            settings: { timeout: 60 }  // Only update timeout
+          }
+        ]
+      })
+    });
+  }
+});
+
+// configs:
+//   - name: database
+//     settings:
+//       timeout: 60    # Updated
+//       pool: 10       # Preserved
+//       ssl: true      # Preserved
+```
+
+## Using `originalValue`
+
+Access original values to make conditional updates:
+
+```typescript
+const yamlString = `
+apiVersion: apps/v1
+kind: Deployment
+spec:
+  replicas: 2
+`;
+
+const { result } = updateYaml({
+  yamlString,
+  annotate: ({ change }) => {
+    change({
+      findKey: (parsed) => parsed.spec,
+      merge: (originalValue) => ({
+        replicas: originalValue.replicas + 1  // Increment by 1
+      }),
+      comment: () => `Scaled from ${originalValue.replicas} to ${originalValue.replicas + 1} replicas`
+    });
+  }
+});
+
+// spec:
+//   # Scaled from 2 to 3 replicas
+//   replicas: 3
+```
+
+### Version Bumping
+
+```typescript
+const yamlString = `
+version: "1.2.3"
+`;
+
+const { result } = updateYaml({
+  yamlString,
+  annotate: ({ change }) => {
+    change({
+      findKey: (parsed) => parsed,
+      merge: (originalValue) => {
+        const [major, minor, patch] = originalValue.version.split('.').map(Number);
+        return {
+          version: `${major}.${minor}.${patch + 1}`
+        };
+      }
+    });
+  }
+});
+
+// version: "1.2.4"
+```
+
+## Multi-Document YAML
+
+### Select Document by Index
+
+```typescript
+const yamlString = `---
+apiVersion: v1
+kind: ConfigMap
+data:
+  key1: value1
+---
+apiVersion: v1
+kind: Secret
+data:
+  key2: value2`;
+
+const { result } = updateYaml({
+  yamlString,
+  selectDocument: () => 1,  // Select second document (Secret)
+  annotate: ({ change }) => {
+    change({
+      findKey: (parsed) => parsed.data,
+      merge: () => ({ key2: 'updated' })
+    });
+  }
+});
+```
+
+### Select Document by Content
+
+```typescript
+const { result } = updateYaml({
+  yamlString,
+  selectDocument: (docs) => {
+    return docs.findIndex(doc => {
+      const parsed = doc.toJSON();
+      return parsed.kind === 'Deployment';
+    });
+  },
+  annotate: ({ change }) => {
+    change({
+      findKey: (parsed) => parsed.spec,
+      merge: () => ({ replicas: 5 })
+    });
+  }
+});
+```
+
+## Real-World Examples
+
+### Kubernetes Deployment Update
+
+```typescript
+const deploymentYaml = `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: myapp
+spec:
+  replicas: 1
+  template:
+    spec:
+      containers:
+        - name: app
+          image: myapp:1.0
+          env:
+            - name: ENV
+              value: dev
+`;
+
+interface K8sDeployment {
+  apiVersion: string;
+  kind: string;
+  metadata: { name: string };
+  spec: {
+    replicas: number;
+    template: {
+      spec: {
+        containers: Array<{
+          name: string;
+          image: string;
+          env?: Array<{ name: string; value: string }>;
+        }>;
+      };
+    };
+  };
+}
+
+const { result } = updateYaml<K8sDeployment>({
+  yamlString: deploymentYaml,
+  annotate: ({ change }) => {
+    // Scale replicas
+    change({
+      findKey: (parsed) => parsed.spec,
+      merge: () => ({ replicas: 3 }),
+      comment: () => 'Scaled to 3 replicas for high availability'
+    });
+
+    // Update container image
+    change({
+      findKey: (parsed) => parsed.spec.template.spec,
+      merge: () => ({
+        ...addInstructions({
+          prop: 'containers',
+          mergeByName: true
+        }),
+        containers: [
+          {
+            name: 'app',
+            image: 'myapp:2.0',
+            env: [
+              { name: 'ENV', value: 'production' }
+            ]
+          }
+        ]
+      }),
+      comment: () => 'Updated to production environment'
+    });
+  }
+});
+```
+
+### ConfigMap Updates
+
+```typescript
+const configMapYaml = `
+apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: app-config
+data:
+  database_host: localhost
+  cache_enabled: "false"
+`;
+
+const { result } = updateYaml({
+  yamlString: configMapYaml,
+  annotate: ({ change }) => {
+    change({
+      findKey: (parsed) => parsed.data,
+      merge: () => ({
+        database_host: 'db.production.com',
+        cache_enabled: 'true',
+        redis_host: 'redis.production.com'
+      }),
+      comment: () => 'Updated for production environment'
+    });
+  }
+});
+
+// apiVersion: v1
+// kind: ConfigMap
+// metadata:
+//   name: app-config
+// data:
+//   # Updated for production environment
+//   database_host: db.production.com
+//   cache_enabled: "true"
+//   redis_host: redis.production.com
+```
+
+### Helm Values Update
+
+```typescript
+const valuesYaml = `
+replicaCount: 1
+
+image:
+  repository: myapp
+  tag: "1.0.0"
+  pullPolicy: IfNotPresent
+
+resources:
+  limits:
+    cpu: 100m
+    memory: 128Mi
+  requests:
+    cpu: 100m
+    memory: 128Mi
+`;
+
+const { result } = updateYaml({
+  yamlString: valuesYaml,
+  annotate: ({ change }) => {
+    change({
+      findKey: (parsed) => parsed,
+      merge: (original) => ({
+        replicaCount: 3,
+        image: {
+          ...original.image,
+          tag: '2.0.0'
+        }
+      })
+    });
+
+    change({
+      findKey: (parsed) => parsed.resources.limits,
+      merge: () => ({
+        cpu: '500m',
+        memory: '512Mi'
+      }),
+      comment: () => 'Increased for production workload'
+    });
+  }
+});
+```
+
+## Advanced Features
+
+### Multiple Changes
+
+Apply multiple changes in a single update:
+
+```typescript
+const { result } = updateYaml({
+  yamlString,
+  annotate: ({ change }) => {
+    change({
+      findKey: (parsed) => parsed.database,
+      merge: () => ({ host: 'db.prod.com' })
+    });
+
+    change({
+      findKey: (parsed) => parsed.cache,
+      merge: () => ({ host: 'cache.prod.com' })
+    });
+
+    change({
+      findKey: (parsed) => parsed.api,
+      merge: () => ({ host: 'api.prod.com' })
+    });
+  }
+});
+```
+
+### Conditional Updates
+
+```typescript
+const { result } = updateYaml({
+  yamlString,
+  annotate: ({ change }) => {
+    change({
+      findKey: (parsed) => parsed.spec,
+      merge: (originalValue) => {
+        const newReplicas = originalValue.replicas < 3
+          ? originalValue.replicas * 2
+          : originalValue.replicas;
+
+        return { replicas: newReplicas };
+      },
+      comment: (prevComment) =>
+        originalValue.replicas < 3
+          ? `Scaled from ${originalValue.replicas} to ${newReplicas}`
+          : prevComment  // Keep existing comment
+    });
+  }
+});
+```
+
+### Preserve and Extend
+
+```typescript
+const { result } = updateYaml({
+  yamlString,
+  annotate: ({ change }) => {
+    change({
+      findKey: (parsed) => parsed.spec,
+      merge: (originalValue) => ({
+        ...originalValue,                    // Preserve all existing
+        replicas: originalValue.replicas + 1, // Update one field
+        newField: 'added'                    // Add new field
+      })
+    });
+  }
+});
+```
+
+## Comment Preservation
+
+Comments are automatically preserved:
+
+```typescript
+const yamlString = `
+# Application configuration
+apiVersion: v1
+kind: ConfigMap
+metadata:
+  # Metadata section
+  name: my-config
+data:
+  # Database configuration
+  database: localhost
+  # Cache configuration
+  cache: redis
+`;
+
+const { result } = updateYaml({
+  yamlString,
+  annotate: ({ change }) => {
+    change({
+      findKey: (parsed) => parsed.data,
+      merge: () => ({ database: 'db.prod.com' })
+    });
+  }
+});
+
+// All comments are preserved!
+// # Application configuration
+// apiVersion: v1
+// kind: ConfigMap
+// metadata:
+//   # Metadata section
+//   name: my-config
+// data:
+//   # Database configuration
+//   database: db.prod.com
+//   # Cache configuration
+//   cache: redis
+```
+
+## Formatting Preservation
+
+Indentation and spacing are maintained:
+
+```typescript
+const yamlString = `
+server:
+  host: localhost
+  port: 3000
+
+
+database:
+  host: localhost
+  port: 5432
+`;
+
+const { result } = updateYaml({
+  yamlString,
+  annotate: ({ change }) => {
+    change({
+      findKey: (parsed) => parsed.server,
+      merge: () => ({ port: 8080 })
+    });
+  }
+});
+
+// Blank lines and indentation preserved
+// server:
+//   host: localhost
+//   port: 8080
+//
+//
+// database:
+//   host: localhost
+//   port: 5432
+```
+
+## Best Practices
+
+### 1. Use Type Parameters
+
+```typescript
+// ✅ Good - Type safe
+const { result } = updateYaml<K8sDeployment>({ ... });
+
+// ❌ Avoid - No type safety
+const { result } = updateYaml({ ... });
+```
+
+### 2. Leverage `originalValue`
+
+```typescript
+// ✅ Good - Conditional based on original
+merge: (originalValue) => ({
+  replicas: originalValue.replicas + 1
+})
+
+// ❌ Avoid - Hardcoded without context
+merge: () => ({ replicas: 3 })
+```
+
+### 3. Use Merge Strategies for Arrays
+
+```typescript
+// ✅ Good - Explicit merge strategy
+...addInstructions({
+  prop: 'containers',
+  mergeByName: true
+})
+
+// ❌ Avoid - Array replacement
+containers: newContainers  // Loses existing items
+```
+
+### 4. Add Meaningful Comments
+
+```typescript
+// ✅ Good - Descriptive comment
+comment: () => 'Scaled to 3 replicas for high availability'
+
+// ❌ Avoid - Obvious or missing comments
+comment: () => 'Updated replicas'
+```
+
+### 5. Handle Multi-Document YAMLs
+
+```typescript
+// ✅ Good - Explicit document selection
+selectDocument: (docs) => {
+  return docs.findIndex(doc =>
+    doc.toJSON().kind === 'Deployment'
+  );
+}
+
+// ❌ Avoid - Assuming single document
+// (works but fails silently with multi-doc)
+```
+
+## Error Handling
+
+The library will throw descriptive errors for invalid YAML:
+
+```typescript
+try {
+  const { result } = updateYaml({
+    yamlString: invalidYaml,
+    annotate: ({ change }) => { ... }
+  });
+} catch (error) {
+  console.error('YAML parsing failed:', error.message);
+}
+```
+
+## Performance Considerations
+
+- **Large Files**: YAML parsing is memory-intensive. Consider streaming for very large files (>10MB).
+- **Many Changes**: Each `change()` call creates proxies and performs deep cloning. Batch related changes when possible.
+- **Comment Operations**: Adding/removing comments requires AST manipulation. Minimal performance impact for normal use.
+
+## Dependencies
+
+- `yaml`: YAML 1.2 parser and stringifier
+- `deep-diff`: Deep object diffing
+- `@hiscojs/object-updater`: Core object manipulation with type-safe updates
+
+## Related Packages
+
+- [@hiscojs/object-updater](https://www.npmjs.com/package/@hiscojs/object-updater) - The underlying object manipulation library
+
+## License
+
+MIT
+
+## Contributing
+
+Issues and pull requests welcome!
+
+## Repository
+
+https://github.com/hisco/yaml-updater

package/dist/index.d.ts

@@ -0,0 +1,94 @@
+import { Document } from 'yaml';
+import { addInstructions as addObjectInstructions } from '@hiscojs/object-updater';
+/**
+ * Re-export addInstructions for convenience
+ */
+export declare const addInstructions: typeof addObjectInstructions;
+/**
+ * Result of updateYaml operation including the YAML string, parsed objects, and comments
+ */
+export interface YamlEdit<T> {
+    result: string;
+    resultParsed: T;
+    originalParsed: T;
+    comments: {
+        path: (string | number)[];
+        comment: string;
+    }[];
+}
+/**
+ * Focused YAML updater - mimics focused-object-updater interface but works with YAML strings.
+ * Internally uses @hiscojs/object-updater for object manipulation and applies changes to YAML AST.
+ *
+ * Type Safety:
+ * - Generic T preserves the type of the parsed YAML object
+ * - Generic L (inferred from findKey) represents the type at the selected path
+ * - The findKey function uses TypeScript's type inference to track nested paths
+ * - The merge function receives originalValue with the correct inferred type L
+ * - Comments are tracked with their paths
+ *
+ * @example Basic YAML update
+ * ```typescript
+ * const yamlString = `
+ * apiVersion: v1
+ * kind: ConfigMap
+ * data:
+ *   database: localhost
+ * `;
+ *
+ * const { result, comments } = updateYaml({
+ *   yamlString,
+ *   annotate: ({ change }) => {
+ *     change({
+ *       findKey: (parsed) => parsed.data,
+ *       merge: () => ({
+ *         database: 'db.production.com',
+ *         cache: 'redis.production.com'
+ *       }),
+ *       comment: () => 'Updated to production endpoints'
+ *     });
+ *   }
+ * });
+ * ```
+ *
+ * @example With addInstructions for array merging
+ * ```typescript
+ * const { result } = updateYaml({
+ *   yamlString: k8sDeployment,
+ *   annotate: ({ change }) => {
+ *     change({
+ *       findKey: (parsed) => parsed.spec.template.spec.containers,
+ *       merge: () => ({
+ *         ...addInstructions({
+ *           prop: 'containers',
+ *           mergeByName: true
+ *         }),
+ *         containers: [
+ *           {
+ *             name: 'app',
+ *             image: 'myapp:2.0'
+ *           }
+ *         ]
+ *       }),
+ *       comment: () => 'Updated container image'
+ *     });
+ *   }
+ * });
+ * ```
+ */
+export declare function updateYaml<T extends object = object>({ yamlString, selectDocument, annotate }: {
+    yamlString: string;
+    selectDocument?: (yamlDocuments: Document[]) => number;
+    annotate?: (annotator: {
+        change: <L>(options: {
+            findKey: (parsed: T) => L;
+            merge: (originalValue: L) => L extends any[] ? unknown[] : L extends object ? {
+                [K in keyof L]?: L[K];
+            } & {
+                [key: string]: unknown;
+            } : L;
+            comment?: (prev?: string) => string | undefined;
+        }) => void;
+    }) => void;
+}): YamlEdit<T>;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAqB,MAAM,MAAM,CAAC;AACnD,OAAO,EAAgB,eAAe,IAAI,qBAAqB,EAAuC,MAAM,yBAAyB,CAAC;AAEtI;;GAEG;AACH,eAAO,MAAM,eAAe,8BAAwB,CAAC;AAErD;;GAEG;AACH,MAAM,WAAW,QAAQ,CAAC,CAAC;IACzB,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,EAAE,CAAC,CAAC;IAChB,cAAc,EAAE,CAAC,CAAC;IAClB,QAAQ,EAAE;QACR,IAAI,EAAE,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,CAAC;QAC1B,OAAO,EAAE,MAAM,CAAC;KACjB,EAAE,CAAC;CACL;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2DG;AACH,wBAAgB,UAAU,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM,EAAE,EACpD,UAAU,EACV,cAAwB,EACxB,QAAQ,EACT,EAAE;IACD,UAAU,EAAE,MAAM,CAAC;IACnB,cAAc,CAAC,EAAE,CAAC,aAAa,EAAE,QAAQ,EAAE,KAAK,MAAM,CAAC;IACvD,QAAQ,CAAC,EAAE,CAAC,SAAS,EAAE;QACrB,MAAM,EAAE,CAAC,CAAC,EAAE,OAAO,EAAE;YACnB,OAAO,EAAE,CAAC,MAAM,EAAE,CAAC,KAAK,CAAC,CAAC;YAC1B,KAAK,EAAE,CAAC,aAAa,EAAE,CAAC,KAAK,CAAC,SAAS,GAAG,EAAE,GACxC,OAAO,EAAE,GACT,CAAC,SAAS,MAAM,GACd;iBAAG,CAAC,IAAI,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;aAAE,GAAG;gBAAE,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;aAAE,GACtD,CAAC,CAAC;YACR,OAAO,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,CAAC;SACjD,KAAK,IAAI,CAAC;KACZ,KAAK,IAAI,CAAC;CACZ,GAAG,QAAQ,CAAC,CAAC,CAAC,CAqMd"}

package/dist/index.js

@@ -0,0 +1,279 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addInstructions = void 0;
+exports.updateYaml = updateYaml;
+const deep_diff_1 = require("deep-diff");
+const yaml_1 = require("yaml");
+const object_updater_1 = require("@hiscojs/object-updater");
+/**
+ * Re-export addInstructions for convenience
+ */
+exports.addInstructions = object_updater_1.addInstructions;
+/**
+ * Focused YAML updater - mimics focused-object-updater interface but works with YAML strings.
+ * Internally uses @hiscojs/object-updater for object manipulation and applies changes to YAML AST.
+ *
+ * Type Safety:
+ * - Generic T preserves the type of the parsed YAML object
+ * - Generic L (inferred from findKey) represents the type at the selected path
+ * - The findKey function uses TypeScript's type inference to track nested paths
+ * - The merge function receives originalValue with the correct inferred type L
+ * - Comments are tracked with their paths
+ *
+ * @example Basic YAML update
+ * ```typescript
+ * const yamlString = `
+ * apiVersion: v1
+ * kind: ConfigMap
+ * data:
+ *   database: localhost
+ * `;
+ *
+ * const { result, comments } = updateYaml({
+ *   yamlString,
+ *   annotate: ({ change }) => {
+ *     change({
+ *       findKey: (parsed) => parsed.data,
+ *       merge: () => ({
+ *         database: 'db.production.com',
+ *         cache: 'redis.production.com'
+ *       }),
+ *       comment: () => 'Updated to production endpoints'
+ *     });
+ *   }
+ * });
+ * ```
+ *
+ * @example With addInstructions for array merging
+ * ```typescript
+ * const { result } = updateYaml({
+ *   yamlString: k8sDeployment,
+ *   annotate: ({ change }) => {
+ *     change({
+ *       findKey: (parsed) => parsed.spec.template.spec.containers,
+ *       merge: () => ({
+ *         ...addInstructions({
+ *           prop: 'containers',
+ *           mergeByName: true
+ *         }),
+ *         containers: [
+ *           {
+ *             name: 'app',
+ *             image: 'myapp:2.0'
+ *           }
+ *         ]
+ *       }),
+ *       comment: () => 'Updated container image'
+ *     });
+ *   }
+ * });
+ * ```
+ */
+function updateYaml({ yamlString, selectDocument = () => 0, annotate }) {
+    // Step 1: Parse YAML
+    const yamlDocuments = (0, yaml_1.parseAllDocuments)(yamlString);
+    const docIndex = selectDocument(yamlDocuments);
+    const originalYamlDocument = yamlDocuments[docIndex];
+    const originalParsed = originalYamlDocument.toJSON();
+    // Step 2: Use focused-object-updater to perform the object transformation
+    // Also track comment instructions from addInstructions
+    const commentInstructionsMap = new Map();
+    // Helper to recursively extract comment instructions from merge result
+    const extractCommentInstructions = (obj, basePath, visited = new WeakSet()) => {
+        if (!obj || typeof obj !== 'object' || visited.has(obj)) {
+            return;
+        }
+        visited.add(obj);
+        // Extract symbols first
+        const symbols = Object.getOwnPropertySymbols(obj);
+        for (const sym of symbols) {
+            const symKey = sym.toString();
+            const propMatch = symKey.match(/Symbol\(merge_(.+)\)/);
+            if (propMatch) {
+                const prop = propMatch[1];
+                const instructions = obj[sym];
+                const fullPath = [...basePath, prop];
+                if (instructions && (instructions.comment || instructions.removeComment || instructions.commentBefore || instructions.commentAfter)) {
+                    commentInstructionsMap.set(JSON.stringify(fullPath), instructions);
+                }
+            }
+        }
+        // Recursively process nested objects (not arrays)
+        const keys = Object.keys(obj);
+        for (const key of keys) {
+            const value = obj[key];
+            if (value && typeof value === 'object' && !Array.isArray(value)) {
+                extractCommentInstructions(value, [...basePath, key], visited);
+            }
+        }
+    };
+    const { result: updatedObject, comments: objectComments } = (0, object_updater_1.updateObject)({
+        sourceObject: originalParsed,
+        annotate: annotate ? (objectAnnotator) => {
+            annotate({
+                change: (options) => {
+                    // Calculate base path ONCE before any merge operations
+                    const basePath = (0, object_updater_1.findKeyByProxy)(originalParsed, options.findKey);
+                    // Cache the merge result to avoid calling options.merge() twice
+                    let mergeResultCache = null;
+                    let mergeCalled = false;
+                    const cachedMerge = (originalValue) => {
+                        if (!mergeCalled) {
+                            mergeResultCache = options.merge(originalValue);
+                            mergeCalled = true;
+                            // Extract comment instructions from the cached result
+                            extractCommentInstructions(mergeResultCache, basePath);
+                        }
+                        return mergeResultCache;
+                    };
+                    objectAnnotator.change({
+                        findKey: options.findKey,
+                        merge: cachedMerge,
+                        comment: options.comment ? (prev) => {
+                            const commentText = options.comment(prev);
+                            if (commentText) {
+                                return {
+                                    text: commentText,
+                                    direction: 'right' // YAML comments don't have direction, but we need this for the interface
+                                };
+                            }
+                            return undefined;
+                        } : undefined
+                    });
+                }
+            });
+        } : undefined
+    });
+    // Step 3: Calculate diff between original and updated objects
+    const diff = (0, deep_diff_1.diff)(originalParsed, updatedObject);
+    // Reverse array diff sequences (same logic as yaml-editor)
+    const locatedArrayIndex = [];
+    if (diff != undefined) {
+        diff.forEach((d, index) => {
+            if (d.kind === 'A') {
+                locatedArrayIndex.push(index);
+            }
+        });
+    }
+    const reversedArrayIndex = reverseArrayDiffSequences(locatedArrayIndex);
+    const clonedDiff = [...(diff == undefined ? [] : diff)];
+    locatedArrayIndex.forEach((index, i) => {
+        if (diff) {
+            clonedDiff[index] = diff[reversedArrayIndex[i]];
+        }
+    });
+    // Step 4: Apply diff to YAML AST
+    clonedDiff.forEach((df) => {
+        if (df.kind === 'N' && df.path) {
+            // New property
+            changeSpecificNodesToNoneFlow(originalYamlDocument, df.path.slice(0, -1));
+            originalYamlDocument.setIn(df.path, originalYamlDocument.createNode(df.rhs, { flow: false }));
+        }
+        else if (df.kind === 'D' && df.path) {
+            // Deleted property
+            originalYamlDocument.deleteIn(df.path);
+        }
+        else if (df.kind === 'E' && df.path) {
+            // Edited property
+            changeSpecificNodesToNoneFlow(originalYamlDocument, df.path.slice(0, -1));
+            originalYamlDocument.setIn(df.path, df.rhs);
+        }
+        else if (df.kind === 'A' && df.path) {
+            // Array change
+            changeSpecificNodesToNoneFlow(originalYamlDocument, df.path.slice(0, -1));
+            originalYamlDocument.addIn(df.path, originalYamlDocument.createNode(df.item.rhs, { flow: false }));
+        }
+    });
+    // Step 5: Apply comments to YAML nodes
+    const comments = [];
+    // First apply comments from the change() comment callback
+    objectComments.forEach(({ path, comment: commentText }) => {
+        const node = originalYamlDocument.getIn(path, true);
+        if (node) {
+            const prevComment = node['commentBefore'];
+            node['commentBefore'] = ' ' + commentText;
+            // If we're adding a comment to an empty object/array, ensure it's not in flow style
+            if (commentText && node.type === 'MAP' && node.items && node.items.length === 0) {
+                node.flow = false;
+            }
+            comments.push({
+                path,
+                comment: commentText
+            });
+        }
+    });
+    // Then apply comment instructions from addInstructions
+    commentInstructionsMap.forEach((instructions, pathKey) => {
+        const path = JSON.parse(pathKey);
+        const node = originalYamlDocument.getIn(path, true);
+        if (node) {
+            if (instructions.removeComment) {
+                // Remove existing comment
+                node['commentBefore'] = undefined;
+            }
+            else if (instructions.comment) {
+                // Add or replace comment
+                node['commentBefore'] = ' ' + instructions.comment;
+                comments.push({
+                    path,
+                    comment: instructions.comment
+                });
+            }
+            else if (instructions.commentBefore) {
+                // Add comment before (same as comment in YAML)
+                node['commentBefore'] = ' ' + instructions.commentBefore;
+                comments.push({
+                    path,
+                    comment: instructions.commentBefore
+                });
+            }
+            // If we're adding a comment to an empty object/array, ensure it's not in flow style
+            if ((instructions.comment || instructions.commentBefore) && node.type === 'MAP' && node.items && node.items.length === 0) {
+                node.flow = false;
+            }
+        }
+    });
+    // Step 6: Stringify YAML
+    const result = originalYamlDocument.toString({ lineWidth: 0 });
+    return {
+        result,
+        resultParsed: updatedObject,
+        originalParsed,
+        comments
+    };
+}
+/**
+ * Helper function to reverse array diff sequences
+ * (copied from yaml-editor.ts)
+ */
+function reverseArrayDiffSequences(array) {
+    const result = [];
+    let start = 0;
+    for (let i = 1; i < array.length; i++) {
+        if (array[i] !== array[i - 1] + 1) {
+            result.push(...array.slice(start, i).reverse());
+            start = i;
+        }
+    }
+    result.push(...array.slice(start).reverse());
+    return result;
+}
+/**
+ * Helper function to change specific nodes to non-flow style
+ * (copied from yaml-editor.ts)
+ */
+function changeSpecificNodesToNoneFlow(originalYamlDocument, path) {
+    const node = originalYamlDocument.getIn(path, true);
+    if (!node) {
+        return;
+    }
+    const isEmptyObject = node.items && Array.isArray(node.items) && node.items.length === 0;
+    const isEmptyArray = node.items && node.items.size === 0;
+    if (node.flow == true && (node.content == '{}' || node.content == '[]' || node.content == null || node.content == undefined || isEmptyObject || isEmptyArray)) {
+        node.flow = false;
+    }
+    if (node.type === 'MAP' && node.items && node.items.length === 0 && node.commentBefore) {
+        node.flow = false;
+    }
+}
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

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

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@hiscojs/yaml-updater",
+  "version": "1.0.0",
+  "description": "Type-safe, immutable YAML updates with comment preservation, multi-document support, and advanced array merging strategies",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "test": "jest",
+    "build": "rm -rf dist && tsc",
+    "prepublishOnly": "npm run build && npm test"
+  },
+  "keywords": [
+    "yaml",
+    "update",
+    "merge",
+    "immutable",
+    "typescript",
+    "type-safe",
+    "proxy",
+    "comment-preservation",
+    "multi-document",
+    "array-merge"
+  ],
+  "author": "",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/hisco/yaml-updater.git"
+  },
+  "dependencies": {
+    "@hiscojs/object-updater": "^1.0.0",
+    "deep-diff": "^1.0.2",
+    "yaml": "^2.7.0"
+  },
+  "devDependencies": {
+    "@jest/globals": "^29.7.0",
+    "@types/deep-diff": "^1.0.5",
+    "@types/jest": "^29.5.14",
+    "@types/node": "^22.10.2",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.2.5",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.7.2"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ]
+}