compact

Compact Codec for JSON Patch

The compact codec provides a space-efficient array-based encoding format for JSON Patch operations. It uses arrays instead of objects to represent operations, significantly reducing the physical space required while maintaining readability.

Format Comparison

Standard JSON format:

{"op": "add", "path": "/foo/bar", "value": 123}

Compact format:

[0, "/foo/bar", 123]

Or with string opcodes:

["add", "/foo/bar", 123]

Usage

Basic Operations

package main

import (
    "fmt"
    "github.com/kaptinlin/jsonpatch/codec/compact"
    "github.com/kaptinlin/jsonpatch/op"
)

func main() {
    // Create operations
    ops := []internal.Op{
        op.NewAdd([]string{"foo"}, "bar"),
        op.NewReplace([]string{"baz"}, 42),
    }
    
    // Encode to compact format
    encoded, err := compact.Encode(ops)
    if err != nil {
        panic(err)
    }
    
    fmt.Printf("Encoded: %v\n", encoded)
    // Output: [[0 "/foo" "bar"] [2 "/baz" 42]]
    
    // Decode back to operations
    decoded, err := compact.Decode(encoded)
    if err != nil {
        panic(err)
    }
    
    fmt.Printf("Decoded: %d operations\n", len(decoded))
}

String Opcodes

// Use string opcodes instead of numeric ones
encoder := compact.NewEncoder(compact.WithStringOpcode(true))
encoded, err := encoder.Encode(ops)
// Result: [["add" "/foo" "bar"] ["replace" "/baz" 42]]

JSON Marshaling

// Encode to JSON bytes
jsonData, err := compact.EncodeJSON(ops)
if err != nil {
    panic(err)
}

// Decode from JSON bytes
decoded, err := compact.DecodeJSON(jsonData)
if err != nil {
    panic(err)
}

Operation Mapping

Standard JSON Patch Operations

Extended Operations

Predicate Operations

API Reference

Encoder

type Encoder struct { ... }

// Create a new encoder
func NewEncoder(opts ...EncoderOption) *Encoder

// Encode a single operation
func (e *Encoder) Encode(op internal.Op) (CompactOp, error)

// Encode multiple operations
func (e *Encoder) EncodeSlice(ops []internal.Op) ([]CompactOp, error)

Decoder

type Decoder struct { ... }

// Create a new decoder
func NewDecoder(opts ...DecoderOption) *Decoder

// Decode a single compact operation
func (d *Decoder) Decode(compactOp CompactOp) (internal.Op, error)

// Decode multiple compact operations
func (d *Decoder) DecodeSlice(compactOps []CompactOp) ([]internal.Op, error)

Standalone Functions

// Encode operations using default options
func Encode(ops []internal.Op, opts ...EncoderOption) ([]CompactOp, error)

// Encode operations to JSON bytes
func EncodeJSON(ops []internal.Op, opts ...EncoderOption) ([]byte, error)

// Decode compact operations using default options
func Decode(compactOps []CompactOp, opts ...DecoderOption) ([]internal.Op, error)

// Decode compact operations from JSON bytes
func DecodeJSON(data []byte, opts ...DecoderOption) ([]internal.Op, error)

Options

// Use string opcodes instead of numeric codes
func WithStringOpcode(useString bool) EncoderOption

Features

• Space Efficient: Significantly smaller than standard JSON format
• Fast: Optimized encoding and decoding performance
• Flexible: Supports both numeric and string opcodes
• Compatible: Works with all existing operation types
• Type Safe: Full Go type safety and error handling

Supported Operations

Currently supports all standard JSON Patch operations and basic extended/predicate operations:

✅ Standard: add, remove, replace, move, copy, test
✅ Extended: flip, inc
✅ Predicates: defined, undefined, contains, starts, ends
⏳ Coming Soon: merge, extend, string operations, composite predicates