gaslamp v0.23.0 Release Notes¶

Released: 2025-09-09
gaslamp: 62 - v0.23.0
pilotlamp: 19 - v0.23.0

🎉 Major Changes¶

🏗️ Complete Design Pattern Implementation for DataFrame¶

Major DataFrame architecture enhancement - Successfully implemented all three design patterns (Strategy, Factory, Builder) for comprehensive DataFrame creation and management:

Strategy Pattern: Implemented for DataFrame format handling with pluggable formatters
Factory Pattern: Enhanced with centralized validation and concrete factory implementations
Builder Pattern: Complete fluent interface implementation for complex DataFrame creation scenarios
Backward Compatibility: All existing functionality preserved with 100% test compatibility
Code Quality: Significantly improved maintainability and extensibility

TypeScript

// New Builder Pattern for complex DataFrame creation
const df = new DataFrameBuilder()
  .withName("ComplexData")
  .withData(data, "arrays")
  .withHeaders(true)
  .withColumns(["name", "score"])
  .withTransform(data => ({ ...data, doubled: data.values.map(v => v * 2) }))
  .build();

// Enhanced Factory Pattern with centralized validation
const mapFactory = new MapDataFrameFactory();
const objectFactory = new ObjectDataFrameFactory();
const arraysFactory = new ArraysDataFrameFactory();

// Strategy Pattern for format handling
df.toString(new TableFormatter());
df.toString(new CSVFormatter());

✨ Enhanced DataFrame Creation Capabilities¶

Comprehensive DataFrame initialization system - Multiple creation patterns now available for different use cases:

Fluent Interface: Method chaining for progressive configuration building
Static Factories: Streamlined creation with DataFrameStaticFactory
Instance Methods: Traditional fromObject(), fromMap(), fromArrays() patterns
Flexible Data Types: Support for object, Map, 2D arrays, and more
Validation System: Centralized validation with detailed error messages

TypeScript

// Multiple creation patterns available
// 1. Builder Pattern (new)
const builderDf = new DataFrameBuilder()
  .withData({ name: ["Alice", "Bob"], age: [25, 30] })
  .build();

// 2. Static Factory (enhanced)
const staticDf = DataFrameStaticFactory.fromObject(data);

// 3. Instance Method (existing)
const instanceDf = new DataFrame().fromObject(data);

🐛 Bug Fixes¶

Factory Pattern Implementation¶

Fixed Protected Method Access: Resolved DataFrame.arraysToMap protected method access issues in fromObject validation
Validation Consistency: Improved error context consistency across all factory implementations
Column Length Validation: Enhanced column length validation integration in Factory Pattern

Builder Pattern Implementation¶

Name Property Propagation: Fixed DataFrame name property not being preserved in select() method operations
Export Missing: Added DataFrameBuilder to module exports for proper accessibility
Test Integration: Resolved test expectation mismatches for header generation patterns

🔧 Refactoring¶

Design Pattern Implementation¶

Strategy Pattern: Implemented Strategy Pattern for DataFrame format handling with pluggable formatter system
Factory Pattern Enhancement: Added centralized validation methods to base DataFrameFactory class with concrete implementations
Builder Pattern: Complete fluent interface implementation with progressive configuration building
Code Consolidation: Unified validation logic across Factory implementations reducing code duplication

Architecture Improvements¶

Class Hierarchy: Established clear inheritance patterns with abstract base classes and concrete implementations
Validation Centralization: Moved common validation logic to base classes for consistency and maintainability
Method Organization: Improved method organization and separation of concerns across pattern implementations

📖 Implementation Details¶

Strategy Pattern Features¶

TypeScript

// Strategy Pattern implementation for format handling
class DataFrameFormatter {
  abstract format(dataframe: DataFrame): string;
}

class TableFormatter extends DataFrameFormatter {
  format(dataframe: DataFrame): string {
    // Table-specific formatting logic
  }
}

class CSVFormatter extends DataFrameFormatter {
  format(dataframe: DataFrame): string {
    // CSV-specific formatting logic
  }
}

Factory Pattern Features¶

TypeScript

// Factory Pattern with centralized validation
abstract class DataFrameFactory {
  protected validateColumnLengths(data: Map<string, unknown[]>): void {
    // Centralized column length validation
  }

  protected validateData(data: any): void {
    // Common data validation logic
  }

  abstract create(data: any, options?: any): DataFrame;
}

// Concrete factory implementations
class ObjectDataFrameFactory extends DataFrameFactory {
  create(data: Record<string, unknown[]>): DataFrame {
    // Object-specific creation logic with validation
  }
}

Builder Pattern Features¶

TypeScript

// Builder Pattern with fluent interface
class DataFrameBuilder {
  private config = {};

  withName(name: string): DataFrameBuilder {
    this.config.name = name;
    return this;
  }

  withData(data: any, dataType?: string): DataFrameBuilder {
    this.config.data = data;
    this.config.dataType = dataType;
    return this;
  }

  withColumns(columns: string[]): DataFrameBuilder {
    this.config.columns = columns;
    return this;
  }

  withTransform(transform: (data: any) => any): DataFrameBuilder {
    this.config.transform = transform;
    return this;
  }

  build(): DataFrame {
    // Validation and DataFrame creation with all configurations
  }
}

🧪 Testing & Quality¶

Test Results¶

✅ All Tests Pass: Comprehensive test suite with 49 test suites, 584 total tests
✅ Builder Pattern Tests: 17 new test cases covering all Builder Pattern functionality
✅ Backward Compatibility: 100% compatibility maintained with existing codebase
✅ Integration Tests: Cross-pattern integration verified

Quality Assurance¶

✅ Code Quality: Enhanced maintainability with clear separation of concerns
✅ Type Safety: Improved TypeScript strict mode compliance
✅ Error Handling: Comprehensive validation and error reporting
✅ Documentation: Complete JSDoc documentation for all new patterns

🚀 Migration Guide¶

For New Users¶

Enhanced Creation Options - Multiple patterns available for different scenarios:

Simple Creation: Use existing fromObject(), fromMap() methods for straightforward cases
Complex Configuration: Use Builder Pattern for scenarios requiring multiple options
Batch Creation: Use Factory Pattern for consistent creation across similar data types

For Existing Users¶

Full Backward Compatibility - All existing code continues to work unchanged:

TypeScript

// Existing code continues to work
const df = new DataFrame().fromObject(data);
const result = df.select(["name", "age"]).filter(row => row.age > 25);

// New patterns available for enhanced functionality
const builderDf = new DataFrameBuilder()
  .withData(data)
  .withColumns(["name", "age"])
  .withTransform(data => ({ ...data, ageGroup: data.age.map(a => a > 30 ? "Senior" : "Junior") }))
  .build();

For Advanced Users¶

Design Pattern Benefits:

Strategy Pattern: Easily extensible formatting system
Factory Pattern: Consistent creation with centralized validation
Builder Pattern: Complex configuration scenarios with fluent interface
Architecture: Improved maintainability and extensibility for custom implementations

🔍 Technical Details¶

Issue #128 Resolution¶

Phase 2 Factory Pattern: Complete implementation with centralized validation and concrete factories
Phase 3 Builder Pattern: Comprehensive fluent interface with progressive configuration building
Architecture Enhancement: All three design patterns successfully integrated
Quality Gates: All build, test, and validation requirements met

Code Metrics¶

New Classes: 4 new pattern implementation classes (DataFrameBuilder, concrete factories)
Test Coverage: 17+ new test cases maintaining comprehensive coverage
Backward Compatibility: 100% existing functionality preserved
Performance: No performance degradation, improved validation efficiency

🎯 What's Next¶

Upcoming Features (v0.24.0)¶

Extended Builder Patterns: Additional configuration options and validation rules
Factory Pattern Extensions: More data source factories (JSON, CSV, Sheet)
Strategy Pattern Expansion: Additional formatter strategies and pluggable systems
Performance Optimizations: Further DataFrame operation optimizations

Long-term Roadmap¶

Advanced Design Patterns: Observer, Command, and other patterns for complex scenarios
Enhanced Type System: Stronger type safety and runtime validation
Plugin Architecture: Extensible system for custom DataFrame operations

👥 Contributors¶

@shotakaha - Complete design pattern implementation and architecture enhancement

🔗 Links¶

Documentation: https://gaslamp.readthedocs.io/
Repository: https://gitlab.com/qumasan/gaslamp

Full Changelog: v0.22.0...v0.23.0