@nahisaho/yata-scale 1.8.5

package/dist/shard/GraphPartitionStrategy.js

@@ -0,0 +1,208 @@
+/**
+ * @nahisaho/yata-scale - Graph Partition Strategy
+ *
+ * Graph-based partitioning using connected components
+ */
+/**
+ * Graph partition strategy based on connected components
+ */
+export class GraphPartitionStrategy {
+    type = 'graph';
+    componentMap = new Map();
+    shardIds;
+    defaultShardId;
+    constructor(shardIds) {
+        if (shardIds.length === 0) {
+            throw new Error('At least one shard is required');
+        }
+        this.shardIds = [...shardIds];
+        this.defaultShardId = shardIds[0];
+    }
+    /**
+     * Initialize the partition map from entities and relationships
+     */
+    async initialize(entities, relationships) {
+        // Build adjacency list
+        const adjacency = new Map();
+        for (const entity of entities) {
+            if (!adjacency.has(entity.id)) {
+                adjacency.set(entity.id, new Set());
+            }
+        }
+        for (const rel of relationships) {
+            if (!adjacency.has(rel.sourceId)) {
+                adjacency.set(rel.sourceId, new Set());
+            }
+            if (!adjacency.has(rel.targetId)) {
+                adjacency.set(rel.targetId, new Set());
+            }
+            adjacency.get(rel.sourceId).add(rel.targetId);
+            adjacency.get(rel.targetId).add(rel.sourceId);
+        }
+        // Find connected components using Union-Find
+        const components = this.findConnectedComponents(adjacency);
+        // Assign components to shards (round-robin by component size)
+        this.assignComponentsToShards(components);
+    }
+    /**
+     * Find connected components using Union-Find
+     */
+    findConnectedComponents(adjacency) {
+        const parent = new Map();
+        const rank = new Map();
+        // Initialize Union-Find
+        for (const id of adjacency.keys()) {
+            parent.set(id, id);
+            rank.set(id, 0);
+        }
+        // Find with path compression
+        const find = (x) => {
+            if (parent.get(x) !== x) {
+                parent.set(x, find(parent.get(x)));
+            }
+            return parent.get(x);
+        };
+        // Union by rank
+        const union = (x, y) => {
+            const rootX = find(x);
+            const rootY = find(y);
+            if (rootX !== rootY) {
+                const rankX = rank.get(rootX);
+                const rankY = rank.get(rootY);
+                if (rankX < rankY) {
+                    parent.set(rootX, rootY);
+                }
+                else if (rankX > rankY) {
+                    parent.set(rootY, rootX);
+                }
+                else {
+                    parent.set(rootY, rootX);
+                    rank.set(rootX, rankX + 1);
+                }
+            }
+        };
+        // Union connected nodes
+        for (const [node, neighbors] of adjacency) {
+            for (const neighbor of neighbors) {
+                union(node, neighbor);
+            }
+        }
+        // Group by component
+        const components = new Map();
+        for (const id of adjacency.keys()) {
+            const root = find(id);
+            if (!components.has(root)) {
+                components.set(root, new Set());
+            }
+            components.get(root).add(id);
+        }
+        return components;
+    }
+    /**
+     * Assign components to shards using best-fit decreasing
+     */
+    assignComponentsToShards(components) {
+        // Sort components by size (descending)
+        const sortedComponents = [...components.entries()].sort((a, b) => b[1].size - a[1].size);
+        // Track shard sizes
+        const shardSizes = new Map();
+        for (const shardId of this.shardIds) {
+            shardSizes.set(shardId, 0);
+        }
+        // Assign each component to the least loaded shard
+        for (const [_componentId, members] of sortedComponents) {
+            // Find shard with minimum load
+            let minShardId = this.shardIds[0];
+            let minSize = Infinity;
+            for (const [shardId, size] of shardSizes) {
+                if (size < minSize) {
+                    minSize = size;
+                    minShardId = shardId;
+                }
+            }
+            // Assign all members to this shard
+            for (const memberId of members) {
+                this.componentMap.set(memberId, minShardId);
+            }
+            // Update shard size
+            shardSizes.set(minShardId, minSize + members.size);
+        }
+    }
+    /**
+     * Get shard ID for an entity
+     */
+    getShardId(entityId, _metadata) {
+        return this.componentMap.get(entityId) ?? this.defaultShardId;
+    }
+    /**
+     * Get shard IDs for multiple entities
+     */
+    getShardIds(entityIds) {
+        const result = new Map();
+        for (const entityId of entityIds) {
+            result.set(entityId, this.getShardId(entityId));
+        }
+        return result;
+    }
+    /**
+     * Calculate remapping (graph partitioning requires recomputation)
+     */
+    remap(_oldShardCount, _newShardCount) {
+        // Graph-based partitioning typically requires full recomputation
+        // Return empty map - caller should reinitialize
+        return new Map();
+    }
+    /**
+     * Add entity to a specific shard
+     */
+    assignEntity(entityId, shardId) {
+        if (!this.shardIds.includes(shardId)) {
+            throw new Error(`Unknown shard: ${shardId}`);
+        }
+        this.componentMap.set(entityId, shardId);
+    }
+    /**
+     * Add entity near related entity (locality)
+     */
+    assignEntityNear(entityId, relatedEntityId) {
+        const shardId = this.componentMap.get(relatedEntityId);
+        if (shardId) {
+            this.componentMap.set(entityId, shardId);
+        }
+        else {
+            this.componentMap.set(entityId, this.defaultShardId);
+        }
+    }
+    /**
+     * Get shard distribution statistics
+     */
+    getDistribution() {
+        const distribution = new Map();
+        for (const shardId of this.shardIds) {
+            distribution.set(shardId, 0);
+        }
+        for (const shardId of this.componentMap.values()) {
+            distribution.set(shardId, (distribution.get(shardId) ?? 0) + 1);
+        }
+        return distribution;
+    }
+    /**
+     * Get all shard IDs
+     */
+    getShardIdsList() {
+        return [...this.shardIds];
+    }
+    /**
+     * Get shard count
+     */
+    get shardCount() {
+        return this.shardIds.length;
+    }
+    /**
+     * Get entity count
+     */
+    get entityCount() {
+        return this.componentMap.size;
+    }
+}
+//# sourceMappingURL=GraphPartitionStrategy.js.map

package/dist/shard/GraphPartitionStrategy.js.map

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

package/dist/shard/HashPartitionStrategy.d.ts

@@ -0,0 +1,56 @@
+/**
+ * @nahisaho/yata-scale - Hash Partition Strategy
+ *
+ * Consistent hash-based partitioning for even distribution
+ */
+import type { PartitionStrategy, PartitionStrategyType, EntityMetadata } from '../types.js';
+/**
+ * Hash partition strategy using consistent hashing
+ */
+export declare class HashPartitionStrategy implements PartitionStrategy {
+    private readonly shardIds;
+    readonly type: PartitionStrategyType;
+    private readonly virtualNodes;
+    private ring;
+    private sortedHashes;
+    constructor(shardIds: string[], options?: {
+        virtualNodes?: number;
+    });
+    /**
+     * Build the consistent hash ring
+     */
+    private buildRing;
+    /**
+     * Simple hash function (FNV-1a variant)
+     */
+    private hash;
+    /**
+     * Find the shard for a given hash using binary search
+     */
+    private findShard;
+    /**
+     * Get shard ID for an entity
+     */
+    getShardId(entityId: string, _metadata?: Partial<EntityMetadata>): string;
+    /**
+     * Calculate remapping when shard count changes
+     */
+    remap(oldShardCount: number, newShardCount: number): Map<string, string>;
+    /**
+     * Find shard excluding certain shards
+     */
+    private findShardExcluding;
+    /**
+     * Add a shard to the ring
+     */
+    addShard(shardId: string): void;
+    /**
+     * Remove a shard from the ring
+     */
+    removeShard(shardId: string): void;
+    /**
+     * Get shard count
+     */
+    get shardCount(): number;
+}
+//# sourceMappingURL=HashPartitionStrategy.d.ts.map

package/dist/shard/HashPartitionStrategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HashPartitionStrategy.d.ts","sourceRoot":"","sources":["../../src/shard/HashPartitionStrategy.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EACV,iBAAiB,EACjB,qBAAqB,EACrB,cAAc,EACf,MAAM,aAAa,CAAC;AAErB;;GAEG;AACH,qBAAa,qBAAsB,YAAW,iBAAiB;IAO3D,OAAO,CAAC,QAAQ,CAAC,QAAQ;IAN3B,SAAgB,IAAI,EAAE,qBAAqB,CAAU;IACrD,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAS;IACtC,OAAO,CAAC,IAAI,CAAkC;IAC9C,OAAO,CAAC,YAAY,CAAgB;gBAGjB,QAAQ,EAAE,MAAM,EAAE,EACnC,OAAO,GAAE;QAAE,YAAY,CAAC,EAAE,MAAM,CAAA;KAAO;IAMzC;;OAEG;IACH,OAAO,CAAC,SAAS;IAejB;;OAEG;IACH,OAAO,CAAC,IAAI;IASZ;;OAEG;IACH,OAAO,CAAC,SAAS;IAuBjB;;OAEG;IACH,UAAU,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,OAAO,CAAC,cAAc,CAAC,GAAG,MAAM;IAgBzE;;OAEG;IACH,KAAK,CAAC,aAAa,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC;IAuBxE;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAyB1B;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAQ/B;;OAEG;IACH,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAgBlC;;OAEG;IACH,IAAI,UAAU,IAAI,MAAM,CAEvB;CACF"}

package/dist/shard/HashPartitionStrategy.js

@@ -0,0 +1,169 @@
+/**
+ * @nahisaho/yata-scale - Hash Partition Strategy
+ *
+ * Consistent hash-based partitioning for even distribution
+ */
+/**
+ * Hash partition strategy using consistent hashing
+ */
+export class HashPartitionStrategy {
+    shardIds;
+    type = 'hash';
+    virtualNodes;
+    ring = new Map();
+    sortedHashes = [];
+    constructor(shardIds, options = {}) {
+        this.shardIds = shardIds;
+        this.virtualNodes = options.virtualNodes ?? 150;
+        this.buildRing();
+    }
+    /**
+     * Build the consistent hash ring
+     */
+    buildRing() {
+        this.ring.clear();
+        this.sortedHashes = [];
+        for (const shardId of this.shardIds) {
+            for (let i = 0; i < this.virtualNodes; i++) {
+                const hash = this.hash(`${shardId}:${i}`);
+                this.ring.set(hash, shardId);
+                this.sortedHashes.push(hash);
+            }
+        }
+        this.sortedHashes.sort((a, b) => a - b);
+    }
+    /**
+     * Simple hash function (FNV-1a variant)
+     */
+    hash(key) {
+        let hash = 2166136261;
+        for (let i = 0; i < key.length; i++) {
+            hash ^= key.charCodeAt(i);
+            hash = Math.imul(hash, 16777619);
+        }
+        return hash >>> 0;
+    }
+    /**
+     * Find the shard for a given hash using binary search
+     */
+    findShard(hash) {
+        if (this.sortedHashes.length === 0) {
+            throw new Error('No shards configured');
+        }
+        // Binary search for the first hash >= target
+        let left = 0;
+        let right = this.sortedHashes.length;
+        while (left < right) {
+            const mid = (left + right) >>> 1;
+            if (this.sortedHashes[mid] < hash) {
+                left = mid + 1;
+            }
+            else {
+                right = mid;
+            }
+        }
+        // Wrap around if we've gone past the end
+        const index = left >= this.sortedHashes.length ? 0 : left;
+        return this.ring.get(this.sortedHashes[index]);
+    }
+    /**
+     * Get shard ID for an entity
+     */
+    getShardId(entityId, _metadata) {
+        const hash = this.hash(entityId);
+        return this.findShard(hash);
+    }
+    /**
+     * Get shard IDs for multiple entities
+     */
+    getShardIds(entityIds) {
+        const result = new Map();
+        for (const entityId of entityIds) {
+            result.set(entityId, this.getShardId(entityId));
+        }
+        return result;
+    }
+    /**
+     * Calculate remapping when shard count changes
+     */
+    remap(oldShardCount, newShardCount) {
+        // For consistent hashing, remapping is minimal
+        // Only keys that were on removed shards need to move
+        const remapping = new Map();
+        if (newShardCount > oldShardCount) {
+            // Adding shards - some keys will move to new shards
+            // This is handled by the ring naturally when rebuilt
+        }
+        else if (newShardCount < oldShardCount) {
+            // Removing shards - keys from removed shards need reassignment
+            const removedShards = this.shardIds.slice(newShardCount);
+            for (const [hash, shardId] of this.ring) {
+                if (removedShards.includes(shardId)) {
+                    // Find new shard for this hash
+                    const newShard = this.findShardExcluding(hash, removedShards);
+                    remapping.set(String(hash), newShard);
+                }
+            }
+        }
+        return remapping;
+    }
+    /**
+     * Find shard excluding certain shards
+     */
+    findShardExcluding(hash, excludeShards) {
+        let left = 0;
+        let right = this.sortedHashes.length;
+        while (left < right) {
+            const mid = (left + right) >>> 1;
+            if (this.sortedHashes[mid] < hash) {
+                left = mid + 1;
+            }
+            else {
+                right = mid;
+            }
+        }
+        // Find first non-excluded shard
+        for (let i = 0; i < this.sortedHashes.length; i++) {
+            const index = (left + i) % this.sortedHashes.length;
+            const shard = this.ring.get(this.sortedHashes[index]);
+            if (!excludeShards.includes(shard)) {
+                return shard;
+            }
+        }
+        throw new Error('No available shards after exclusion');
+    }
+    /**
+     * Add a shard to the ring
+     */
+    addShard(shardId) {
+        if (this.shardIds.includes(shardId)) {
+            return;
+        }
+        this.shardIds.push(shardId);
+        this.buildRing();
+    }
+    /**
+     * Remove a shard from the ring
+     */
+    removeShard(shardId) {
+        const index = this.shardIds.indexOf(shardId);
+        if (index === -1) {
+            return;
+        }
+        this.shardIds.splice(index, 1);
+        this.buildRing();
+    }
+    /**
+     * Get all shard IDs
+     */
+    getShardIds() {
+        return [...this.shardIds];
+    }
+    /**
+     * Get shard count
+     */
+    get shardCount() {
+        return this.shardIds.length;
+    }
+}
+//# sourceMappingURL=HashPartitionStrategy.js.map

package/dist/shard/HashPartitionStrategy.js.map

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

package/dist/shard/RangePartitionStrategy.d.ts

@@ -0,0 +1,63 @@
+/**
+ * @nahisaho/yata-scale - Range Partition Strategy
+ *
+ * Range-based partitioning for ordered data distribution
+ */
+import type { PartitionStrategy, PartitionStrategyType, EntityMetadata } from '../types.js';
+/**
+ * Range configuration for a shard
+ */
+export interface RangeConfig {
+    readonly shardId: string;
+    readonly start: string;
+    readonly end: string;
+}
+/**
+ * Range partition strategy for ordered key distribution
+ */
+export declare class RangePartitionStrategy implements PartitionStrategy {
+    readonly type: PartitionStrategyType;
+    private ranges;
+    constructor(ranges: RangeConfig[]);
+    /**
+     * Validate ranges don't overlap and sort them
+     */
+    private validateAndSortRanges;
+    /**
+     * Extract partition key from entity ID or metadata
+     */
+    private extractPartitionKey;
+    /**
+     * Get shard ID for an entity using binary search
+     */
+    getShardId(entityId: string, metadata?: Partial<EntityMetadata>): string;
+    /**
+     * Get shard IDs for multiple entities
+     */
+    getShardIds(entityIds: string[]): Map<string, string>;
+    /**
+     * Calculate remapping when ranges change
+     */
+    remap(oldShardCount: number, newShardCount: number): Map<string, string>;
+    /**
+     * Split a range into two
+     */
+    splitRange(shardId: string, splitPoint: string, newShardId: string): RangeConfig[];
+    /**
+     * Merge two adjacent ranges
+     */
+    mergeRanges(shardId1: string, shardId2: string, mergedShardId: string): RangeConfig;
+    /**
+     * Get all ranges
+     */
+    getRanges(): readonly RangeConfig[];
+    /**
+     * Get all shard IDs
+     */
+    getShardIdsList(): string[];
+    /**
+     * Get shard count
+     */
+    get shardCount(): number;
+}
+//# sourceMappingURL=RangePartitionStrategy.d.ts.map

package/dist/shard/RangePartitionStrategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RangePartitionStrategy.d.ts","sourceRoot":"","sources":["../../src/shard/RangePartitionStrategy.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EACV,iBAAiB,EACjB,qBAAqB,EACrB,cAAc,EACf,MAAM,aAAa,CAAC;AAErB;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;CACtB;AAED;;GAEG;AACH,qBAAa,sBAAuB,YAAW,iBAAiB;IAC9D,SAAgB,IAAI,EAAE,qBAAqB,CAAW;IACtD,OAAO,CAAC,MAAM,CAAgB;gBAElB,MAAM,EAAE,WAAW,EAAE;IAIjC;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAoB7B;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAW3B;;OAEG;IACH,UAAU,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,OAAO,CAAC,cAAc,CAAC,GAAG,MAAM;IA6BxE;;OAEG;IACH,WAAW,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC;IAQrD;;OAEG;IACH,KAAK,CAAC,aAAa,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC;IAaxE;;OAEG;IACH,UAAU,CACR,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,GACjB,WAAW,EAAE;IAuBhB;;OAEG;IACH,WAAW,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,WAAW;IA8BnF;;OAEG;IACH,SAAS,IAAI,SAAS,WAAW,EAAE;IAInC;;OAEG;IACH,eAAe,IAAI,MAAM,EAAE;IAI3B;;OAEG;IACH,IAAI,UAAU,IAAI,MAAM,CAEvB;CACF"}

package/dist/shard/RangePartitionStrategy.js

@@ -0,0 +1,157 @@
+/**
+ * @nahisaho/yata-scale - Range Partition Strategy
+ *
+ * Range-based partitioning for ordered data distribution
+ */
+/**
+ * Range partition strategy for ordered key distribution
+ */
+export class RangePartitionStrategy {
+    type = 'range';
+    ranges;
+    constructor(ranges) {
+        this.ranges = this.validateAndSortRanges(ranges);
+    }
+    /**
+     * Validate ranges don't overlap and sort them
+     */
+    validateAndSortRanges(ranges) {
+        if (ranges.length === 0) {
+            throw new Error('At least one range is required');
+        }
+        // Sort by start key
+        const sorted = [...ranges].sort((a, b) => a.start.localeCompare(b.start));
+        // Check for overlaps
+        for (let i = 0; i < sorted.length - 1; i++) {
+            if (sorted[i].end > sorted[i + 1].start) {
+                throw new Error(`Range overlap detected between ${sorted[i].shardId} and ${sorted[i + 1].shardId}`);
+            }
+        }
+        return sorted;
+    }
+    /**
+     * Extract partition key from entity ID or metadata
+     */
+    extractPartitionKey(entityId, metadata) {
+        // If namespace is available, use namespace:id format
+        if (metadata?.source) {
+            return `${metadata.source}:${entityId}`;
+        }
+        return entityId;
+    }
+    /**
+     * Get shard ID for an entity using binary search
+     */
+    getShardId(entityId, metadata) {
+        const key = this.extractPartitionKey(entityId, metadata);
+        // Binary search for the correct range
+        let left = 0;
+        let right = this.ranges.length - 1;
+        while (left <= right) {
+            const mid = (left + right) >>> 1;
+            const range = this.ranges[mid];
+            if (key < range.start) {
+                right = mid - 1;
+            }
+            else if (key >= range.end) {
+                left = mid + 1;
+            }
+            else {
+                return range.shardId;
+            }
+        }
+        // If key is before first range, use first shard
+        if (key < this.ranges[0].start) {
+            return this.ranges[0].shardId;
+        }
+        // If key is after last range, use last shard
+        return this.ranges[this.ranges.length - 1].shardId;
+    }
+    /**
+     * Get shard IDs for multiple entities
+     */
+    getShardIds(entityIds) {
+        const result = new Map();
+        for (const entityId of entityIds) {
+            result.set(entityId, this.getShardId(entityId));
+        }
+        return result;
+    }
+    /**
+     * Calculate remapping when ranges change
+     */
+    remap(oldShardCount, newShardCount) {
+        const remapping = new Map();
+        // Range-based partitioning requires explicit range reconfiguration
+        // This method returns the keys that would need to move
+        if (newShardCount !== oldShardCount) {
+            // In range partitioning, remapping depends on how ranges are split/merged
+            // This is a placeholder - actual implementation depends on split strategy
+        }
+        return remapping;
+    }
+    /**
+     * Split a range into two
+     */
+    splitRange(shardId, splitPoint, newShardId) {
+        const index = this.ranges.findIndex((r) => r.shardId === shardId);
+        if (index === -1) {
+            throw new Error(`Shard not found: ${shardId}`);
+        }
+        const range = this.ranges[index];
+        if (splitPoint <= range.start || splitPoint >= range.end) {
+            throw new Error(`Split point ${splitPoint} is outside range [${range.start}, ${range.end})`);
+        }
+        const newRanges = [
+            { shardId: range.shardId, start: range.start, end: splitPoint },
+            { shardId: newShardId, start: splitPoint, end: range.end },
+        ];
+        // Replace old range with new ranges
+        this.ranges.splice(index, 1, ...newRanges);
+        return newRanges;
+    }
+    /**
+     * Merge two adjacent ranges
+     */
+    mergeRanges(shardId1, shardId2, mergedShardId) {
+        const index1 = this.ranges.findIndex((r) => r.shardId === shardId1);
+        const index2 = this.ranges.findIndex((r) => r.shardId === shardId2);
+        if (index1 === -1 || index2 === -1) {
+            throw new Error('One or both shards not found');
+        }
+        // Ensure they are adjacent
+        if (Math.abs(index1 - index2) !== 1) {
+            throw new Error('Ranges must be adjacent to merge');
+        }
+        const [firstIndex, secondIndex] = index1 < index2 ? [index1, index2] : [index2, index1];
+        const firstRange = this.ranges[firstIndex];
+        const secondRange = this.ranges[secondIndex];
+        const mergedRange = {
+            shardId: mergedShardId,
+            start: firstRange.start,
+            end: secondRange.end,
+        };
+        // Replace both ranges with merged range
+        this.ranges.splice(firstIndex, 2, mergedRange);
+        return mergedRange;
+    }
+    /**
+     * Get all ranges
+     */
+    getRanges() {
+        return this.ranges;
+    }
+    /**
+     * Get all shard IDs
+     */
+    getShardIdsList() {
+        return this.ranges.map((r) => r.shardId);
+    }
+    /**
+     * Get shard count
+     */
+    get shardCount() {
+        return this.ranges.length;
+    }
+}
+//# sourceMappingURL=RangePartitionStrategy.js.map