@objectql/driver-fs 4.0.2 → 4.0.4

package/CHANGELOG.md

@@ -1,5 +1,65 @@
 # Changelog
 
+## 4.0.4
+
+### Patch Changes
+
+- **Patch Release v4.0.4**
+
+  This patch release includes bug fixes, driver improvements, and enhanced test coverage:
+
+  ### Driver Improvements
+  - **MongoDB Driver**: Fixed bulk operations, transaction support, and type safety improvements
+  - **FileSystem Driver**: Fixed TCK test compatibility with dataDir parameter
+  - **SQL Driver**: Enhanced TCK test compatibility and fixed test failures
+  - **Redis Driver**: Improved TCK test configuration and dependencies
+  - **Driver Utils**: Added shared utilities package for cross-driver functionality
+
+  ### Testing & Quality
+  - Added comprehensive TCK (Technology Compatibility Kit) compliance tests for all drivers
+  - Expanded TCK test suite to 30+ comprehensive tests
+  - Enhanced test infrastructure with better error handling
+  - Added --passWithNoTests flag for packages without tests
+
+  ### Type Safety
+  - Improved type safety in MongoDB driver update methods
+  - Better handling of atomic operators in MongoDB driver
+  - Enhanced type definitions across driver layer
+
+  ### Documentation
+  - Added comprehensive driver documentation
+  - Enhanced official documentation with Phase 2 implementation summaries
+  - Improved protocol layer documentation
+
+  ### Infrastructure
+  - Standardized driver layer implementation
+  - Enhanced protocol layer with better abstraction
+  - Improved GitHub Actions workflow configurations
+  - Better CI/CD pipeline stability
+
+  This release maintains full backward compatibility with v4.0.3.
+
+- Updated dependencies
+  - @objectql/driver-memory@4.0.4
+  - @objectql/types@4.0.4
+
+## 4.0.3
+
+### Patch Changes
+
+- **Patch Release v4.0.3**
+
+  This patch release includes infrastructure improvements and development experience enhancements:
+  - Refactored dev server setup for improved configuration handling
+  - Enhanced example scripts and development workflow
+  - Updated build and test infrastructure
+  - Improved documentation and developer tools
+  - Bug fixes and stability improvements
+
+- Updated dependencies
+  - @objectql/driver-memory@4.0.3
+  - @objectql/types@4.0.3
+
 ## 4.0.2
 
 ### Patch Changes

package/dist/index.d.ts

@@ -1,6 +1,4 @@
-import { Data } from '@objectstack/spec';
-type QueryAST = Data.QueryAST;
-import { Driver } from '@objectql/types';
+import { MemoryDriver, MemoryDriverConfig } from '@objectql/driver-memory';
 /**
  * Command interface for executeCommand method
  */
@@ -29,218 +27,81 @@ export interface CommandResult {
 /**
  * Configuration options for the FileSystem driver.
  */
-export interface FileSystemDriverConfig {
+export interface FileSystemDriverConfig extends MemoryDriverConfig {
     /** Directory path where JSON files will be stored */
     dataDir: string;
     /** Optional: Enable pretty-print JSON for readability (default: true) */
     prettyPrint?: boolean;
     /** Optional: Enable backup files on write (default: true) */
     enableBackup?: boolean;
-    /** Optional: Enable strict mode (throw on missing objects) */
-    strictMode?: boolean;
-    /** Optional: Initial data to populate the store */
-    initialData?: Record<string, any[]>;
 }
 /**
  * FileSystem Driver Implementation
  *
+ * Extends MemoryDriver with file system persistence.
+ * All query and aggregation logic is inherited from MemoryDriver.
+ * Only the persistence layer (load/save) is overridden.
+ *
  * Stores ObjectQL documents in JSON files with format:
  * - File: `{dataDir}/{objectName}.json`
  * - Content: Array of records `[{id: "1", ...}, {id: "2", ...}]`
  */
-export declare class FileSystemDriver implements Driver {
-    readonly name = "FileSystemDriver";
-    readonly version = "4.0.0";
-    readonly supports: {
-        transactions: boolean;
-        joins: boolean;
-        fullTextSearch: boolean;
-        jsonFields: boolean;
-        arrayFields: boolean;
-        queryFilters: boolean;
-        queryAggregations: boolean;
-        querySorting: boolean;
-        queryPagination: boolean;
-        queryWindowFunctions: boolean;
-        querySubqueries: boolean;
-    };
-    private config;
-    private idCounters;
+export declare class FileSystemDriver extends MemoryDriver {
+    private dataDir;
+    private prettyPrint;
+    private enableBackup;
     private cache;
     constructor(config: FileSystemDriverConfig);
     /**
-     * Connect to the database (for DriverInterface compatibility)
-     * This is a no-op for filesystem driver as there's no external connection.
-     */
-    connect(): Promise<void>;
-    /**
-     * Check database connection health
+     * Load all JSON files from disk into memory
      */
-    checkHealth(): Promise<boolean>;
+    protected loadAllFromDisk(): void;
     /**
-     * Load initial data into the store.
+     * Load records for an object type from disk
      */
-    private loadInitialData;
+    protected loadRecordsFromDisk(objectName: string): any[];
     /**
-     * Get the file path for an object type.
+     * Save records for an object type to disk
      */
-    private getFilePath;
+    protected saveRecordsToDisk(objectName: string, records: any[]): void;
     /**
-     * Load records from file into memory cache.
+     * Get file path for an object type
      */
-    private loadRecords;
+    protected getFilePath(objectName: string): string;
     /**
-     * Save records to file with atomic write strategy.
-     */
-    private saveRecords;
-    /**
-     * Find multiple records matching the query criteria.
-     */
-    find(objectName: string, query?: any, options?: any): Promise<any[]>;
-    /**
-     * Find a single record by ID or query.
-     */
-    findOne(objectName: string, id: string | number, query?: any, options?: any): Promise<any>;
-    /**
-     * Create a new record.
+     * Override create to persist to disk
      */
     create(objectName: string, data: any, options?: any): Promise<any>;
     /**
-     * Update an existing record.
+     * Override update to persist to disk
      */
     update(objectName: string, id: string | number, data: any, options?: any): Promise<any>;
     /**
-     * Delete a record.
+     * Override delete to persist to disk
      */
     delete(objectName: string, id: string | number, options?: any): Promise<any>;
     /**
-     * Count records matching filters.
-     */
-    count(objectName: string, filters: any, options?: any): Promise<number>;
-    /**
-     * Get distinct values for a field.
-     */
-    distinct(objectName: string, field: string, filters?: any, options?: any): Promise<any[]>;
-    /**
-     * Create multiple records at once.
-     */
-    createMany(objectName: string, data: any[], options?: any): Promise<any>;
-    /**
-     * Update multiple records matching filters.
-     */
-    updateMany(objectName: string, filters: any, data: any, options?: any): Promise<any>;
-    /**
-     * Delete multiple records matching filters.
-     */
-    deleteMany(objectName: string, filters: any, options?: any): Promise<any>;
-    /**
-     * Disconnect (flush cache).
-     */
-    disconnect(): Promise<void>;
-    /**
-     * Clear all data from a specific object.
-     * Useful for testing or data reset scenarios.
+     * Override find to load from disk if not in cache
      */
-    clear(objectName: string): Promise<void>;
+    find(objectName: string, query?: any, options?: any): Promise<any[]>;
     /**
-     * Clear all data from all objects.
-     * Removes all JSON files in the data directory.
+     * Sync an object type's data to disk
      */
-    clearAll(): Promise<void>;
+    protected syncObjectToDisk(objectName: string): void;
     /**
-     * Invalidate cache for a specific object.
-     * Forces reload from file on next access.
+     * Clear cache for an object
      */
-    invalidateCache(objectName: string): void;
+    invalidateCache(objectName?: string): void;
     /**
-     * Get the size of the cache (number of objects cached).
+     * Get the number of cached objects
      */
     getCacheSize(): number;
     /**
-     * Execute a query using QueryAST (DriverInterface v4.0 method)
-     *
-     * This method handles all query operations using the standard QueryAST format
-     * from @objectstack/spec. It converts the AST to the legacy query format
-     * and delegates to the existing find() method.
-     *
-     * @param ast - The query AST to execute
-     * @param options - Optional execution options
-     * @returns Query results with value array and count
-     */
-    executeQuery(ast: QueryAST, options?: any): Promise<{
-        value: any[];
-        count?: number;
-    }>;
-    /**
-     * Execute a command (DriverInterface v4.0 method)
-     *
-     * This method handles all mutation operations (create, update, delete)
-     * using a unified command interface.
-     *
-     * @param command - The command to execute
-     * @param options - Optional execution options
-     * @returns Command execution result
-     */
-    executeCommand(command: Command, options?: any): Promise<CommandResult>;
-    /**
-     * Execute raw command (for compatibility)
-     *
-     * @param command - Command string or object
-     * @param parameters - Command parameters
-     * @param options - Execution options
-     */
-    execute(command: any, parameters?: any[], options?: any): Promise<any>;
-    /**
-     * Convert FilterCondition (MongoDB-like format) to legacy array format.
-     * This allows the fs driver to use its existing filter evaluation logic.
-     *
-     * @param condition - FilterCondition object or legacy array
-     * @returns Legacy filter array format
-     */
-    private convertFilterConditionToArray;
-    /**
-     * Normalizes query format to support both legacy UnifiedQuery and QueryAST formats.
-     * This ensures backward compatibility while supporting the new @objectstack/spec interface.
-     *
-     * QueryAST format uses:
-     * - 'where' with MongoDB-like filters (convert to 'filters' array)
-     * - 'orderBy' with array of {field, order} (convert to 'sort' with [field, order])
-     * - 'offset' (convert to 'skip')
-     * - 'top' (convert to 'limit')
+     * Clear data for a specific object or all data
      */
-    private normalizeQuery;
+    clear(objectName?: string): Promise<void>;
     /**
-     * Apply filters to an array of records.
-     *
-     * Supports ObjectQL filter format with logical operators (AND/OR):
-     * [
-     *   ['field', 'operator', value],
-     *   'or',
-     *   ['field2', 'operator', value2]
-     * ]
+     * Clear all data from the store and disk
      */
-    private applyFilters;
-    /**
-     * Check if a single record matches the filter conditions.
-     */
-    private matchesFilters;
-    /**
-     * Evaluate a single filter condition.
-     */
-    private evaluateCondition;
-    /**
-     * Apply sorting to an array of records.
-     */
-    private applySort;
-    /**
-     * Project specific fields from a document.
-     */
-    private projectFields;
-    /**
-     * Generate a unique ID for a record.
-     * Uses timestamp + counter for uniqueness.
-     * Note: For production use with high-frequency writes, consider using crypto.randomUUID().
-     */
-    private generateId;
+    clearAll(): Promise<void>;
 }
-export {};