@feltdb/core 0.2.0 → 0.4.0

package/dist/query-planner.js

@@ -0,0 +1,184 @@
+/**
+ * Query Planner - Cost-Based Index Selection
+ *
+ * Analyzes queries and selects the optimal index to use.
+ * Uses cardinality estimation and index statistics to minimize query cost.
+ */
+export class QueryPlanner {
+    /**
+     * Analyze a predicate and select the best index.
+     */
+    static planQuery(predicates, indexes) {
+        if (indexes.length === 0) {
+            return null;
+        }
+        const scoreboard = indexes.map(index => this.scoreIndex(predicates, index));
+        // Return index with highest score (best coverage and lowest cost)
+        return scoreboard.reduce((best, current) => (current.score > best.score ? current : best));
+    }
+    /**
+     * Score how well an index covers the given predicates.
+     */
+    static scoreIndex(predicates, index) {
+        const indexFields = index.fields || (index.field ? [index.field] : []);
+        const textFields = index.textFields || [];
+        const allIndexFields = [...indexFields, ...textFields];
+        // Calculate coverage: how many predicates can this index handle
+        const coveredPredicates = predicates.filter(p => allIndexFields.includes(p.field));
+        const coverage = coveredPredicates.length / Math.max(predicates.length, 1);
+        // Calculate cost based on index type
+        let cost = 100; // Base cost
+        let estimatedRows = 1000; // Base estimate
+        if (index.type === 'hash') {
+            // Hash index: O(1) lookup
+            cost = coveredPredicates.length > 0 ? 5 : 100;
+            estimatedRows = coveredPredicates.length > 0 ? 10 : 1000;
+        }
+        else if (index.type === 'sorted') {
+            // Sorted index: O(log n) lookup
+            cost = coveredPredicates.length > 0 ? 10 : 100;
+            estimatedRows = coveredPredicates.length > 0 ? 50 : 1000;
+        }
+        else if (index.type === 'compound') {
+            // Compound index: benefits from multiple field coverage
+            const matchedFields = indexFields.filter(f => predicates.some(p => p.field === f));
+            const matchRatio = matchedFields.length / indexFields.length;
+            cost = matchRatio > 0.5 ? 8 : 50;
+            estimatedRows = matchRatio > 0.5 ? 20 : 500;
+        }
+        else if (index.type === 'text') {
+            // Text index: for full-text search
+            cost = coveredPredicates.some(p => p.operator === 'contains') ? 15 : 100;
+            estimatedRows = coveredPredicates.some(p => p.operator === 'contains') ? 100 : 1000;
+        }
+        // Bonus for exact matches and range queries
+        const exactMatches = coveredPredicates.filter(p => p.operator === 'eq' || p.operator === 'range').length;
+        cost -= exactMatches * 2;
+        // Score: higher coverage and lower cost is better
+        const score = coverage * 100 - cost;
+        return {
+            indexName: index.name,
+            indexType: index.type,
+            fields: allIndexFields,
+            score: Math.max(0, score),
+            coverage,
+            estimatedRows,
+            cost,
+        };
+    }
+    /**
+     * Explain the query plan (for debugging).
+     */
+    static explainPlan(predicates, indexes, selectedIndex) {
+        if (indexes.length === 0) {
+            return 'FULL_SCAN: No indexes available';
+        }
+        if (!selectedIndex) {
+            return 'FULL_SCAN: No suitable index found';
+        }
+        return (`INDEX_SCAN: ${selectedIndex.indexName} (${selectedIndex.indexType}) ` +
+            `coverage=${(selectedIndex.coverage * 100).toFixed(0)}% ` +
+            `cost=${selectedIndex.cost} ` +
+            `estimatedRows=${selectedIndex.estimatedRows}`);
+    }
+}
+/**
+ * Compound query builder for multi-field searches.
+ */
+export class CompoundQuery {
+    constructor() {
+        this.predicates = new Map();
+        this.fields = [];
+    }
+    /**
+     * Add a predicate for a field.
+     */
+    addPredicate(field, operator, value) {
+        this.predicates.set(field, { field, operator, value });
+        if (!this.fields.includes(field)) {
+            this.fields.push(field);
+        }
+        return this;
+    }
+    /**
+     * Get all predicates.
+     */
+    getPredicates() {
+        return Array.from(this.predicates.values());
+    }
+    /**
+     * Get fields involved in this query.
+     */
+    getFields() {
+        return [...this.fields];
+    }
+    /**
+     * Find best index for this compound query.
+     */
+    planWith(indexes) {
+        return QueryPlanner.planQuery(this.getPredicates(), indexes);
+    }
+}
+/**
+ * Index recommendation engine - suggests indexes to create.
+ */
+export class IndexRecommender {
+    /**
+     * Analyze query patterns and recommend indexes.
+     */
+    static recommendIndexes(queries) {
+        const fieldFrequency = new Map();
+        const fieldOperators = new Map();
+        // Analyze query patterns
+        for (const query of queries) {
+            for (const predicate of query) {
+                fieldFrequency.set(predicate.field, (fieldFrequency.get(predicate.field) || 0) + 1);
+                if (!fieldOperators.has(predicate.field)) {
+                    fieldOperators.set(predicate.field, new Set());
+                }
+                fieldOperators.get(predicate.field).add(predicate.operator);
+            }
+        }
+        const recommendations = [];
+        const totalQueries = queries.length;
+        // Recommend indexes for frequently queried fields
+        for (const [field, frequency] of fieldFrequency) {
+            const queryRatio = frequency / totalQueries;
+            // Only recommend indexes for fields queried in > 10% of queries
+            if (queryRatio < 0.1)
+                continue;
+            const operators = fieldOperators.get(field);
+            // Recommend hash index for equality queries
+            if (operators.has('eq') && queryRatio > 0.15) {
+                recommendations.push({
+                    name: `idx_${field}_hash`,
+                    type: 'hash',
+                    field,
+                    inmemory: true,
+                    persistent: true,
+                });
+            }
+            // Recommend sorted index for range queries
+            if ((operators.has('gt') || operators.has('lt') || operators.has('range')) && queryRatio > 0.1) {
+                recommendations.push({
+                    name: `idx_${field}_sorted`,
+                    type: 'sorted',
+                    field,
+                    inmemory: true,
+                    persistent: true,
+                });
+            }
+            // Recommend text index for text search
+            if (operators.has('contains') && queryRatio > 0.1) {
+                recommendations.push({
+                    name: `idx_${field}_text`,
+                    type: 'text',
+                    textFields: [field],
+                    inmemory: true,
+                    persistent: true,
+                });
+            }
+        }
+        return recommendations;
+    }
+}

package/dist/release.d.ts

@@ -0,0 +1,60 @@
+export interface CiAttestation {
+    provider: string;
+    run_id: string;
+    commit: string;
+    status: string;
+    checks: Record<string, boolean>;
+    artifacts: Record<string, string>;
+    generated_at: number | string;
+}
+export interface ReleaseManifest {
+    release_id: string;
+    version: string;
+    application_id: string;
+    revision_id: string;
+    bundle_id: string;
+    source_commit: string;
+    artifacts: {
+        name: string;
+        artifact_type: string;
+        digest: string;
+        size: number;
+    }[];
+    packages: {
+        name: string;
+        artifact_type: string;
+        digest: string;
+        size: number;
+    }[];
+    runtime: Record<string, string>;
+    environment: Record<string, string>;
+    parent_release?: string;
+    ci_attestation: CiAttestation;
+    release_attestation?: string;
+    digest: string;
+    created_at: number;
+}
+export interface Release {
+    manifest: ReleaseManifest;
+    status: 'CANDIDATE' | 'VERIFIED' | 'PROMOTED' | 'REVOKED';
+    created_by: string;
+}
+export declare class ReleaseClient {
+    private baseUrl;
+    private fetcher;
+    constructor(baseUrl?: string, fetcher?: typeof fetch);
+    private json;
+    create(manifest: ReleaseManifest): Promise<Release>;
+    list(applicationId: string): Promise<{
+        releases: Release[];
+    }>;
+    get(id: string): Promise<Release>;
+    verify(id: string): Promise<Release>;
+    promote(id: string, applicationId: string, environment: string): Promise<Release>;
+    plan(releaseId: string, environment: string, rollbackTarget?: string): Promise<unknown>;
+    deploy(plan: unknown): Promise<unknown>;
+    status(id: string): Promise<unknown>;
+    health(id: string): Promise<unknown>;
+    stop(id: string): Promise<unknown>;
+}
+//# sourceMappingURL=release.d.ts.map

package/dist/release.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"release.d.ts","sourceRoot":"","sources":["../src/release.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,aAAa;IAAC,QAAQ,EAAC,MAAM,CAAC;IAAA,MAAM,EAAC,MAAM,CAAC;IAAA,MAAM,EAAC,MAAM,CAAC;IAAA,MAAM,EAAC,MAAM,CAAC;IAAA,MAAM,EAAC,MAAM,CAAC,MAAM,EAAC,OAAO,CAAC,CAAC;IAAA,SAAS,EAAC,MAAM,CAAC,MAAM,EAAC,MAAM,CAAC,CAAC;IAAA,YAAY,EAAC,MAAM,GAAC,MAAM,CAAA;CAAC;AAClL,MAAM,WAAW,eAAe;IAAC,UAAU,EAAC,MAAM,CAAC;IAAA,OAAO,EAAC,MAAM,CAAC;IAAA,cAAc,EAAC,MAAM,CAAC;IAAA,WAAW,EAAC,MAAM,CAAC;IAAA,SAAS,EAAC,MAAM,CAAC;IAAA,aAAa,EAAC,MAAM,CAAC;IAAA,SAAS,EAAC;QAAC,IAAI,EAAC,MAAM,CAAC;QAAA,aAAa,EAAC,MAAM,CAAC;QAAA,MAAM,EAAC,MAAM,CAAC;QAAA,IAAI,EAAC,MAAM,CAAA;KAAC,EAAE,CAAC;IAAA,QAAQ,EAAC;QAAC,IAAI,EAAC,MAAM,CAAC;QAAA,aAAa,EAAC,MAAM,CAAC;QAAA,MAAM,EAAC,MAAM,CAAC;QAAA,IAAI,EAAC,MAAM,CAAA;KAAC,EAAE,CAAC;IAAA,OAAO,EAAC,MAAM,CAAC,MAAM,EAAC,MAAM,CAAC,CAAC;IAAA,WAAW,EAAC,MAAM,CAAC,MAAM,EAAC,MAAM,CAAC,CAAC;IAAA,cAAc,CAAC,EAAC,MAAM,CAAC;IAAA,cAAc,EAAC,aAAa,CAAC;IAAA,mBAAmB,CAAC,EAAC,MAAM,CAAC;IAAA,MAAM,EAAC,MAAM,CAAC;IAAA,UAAU,EAAC,MAAM,CAAA;CAAC;AACld,MAAM,WAAW,OAAO;IAAC,QAAQ,EAAC,eAAe,CAAC;IAAA,MAAM,EAAC,WAAW,GAAC,UAAU,GAAC,UAAU,GAAC,SAAS,CAAC;IAAA,UAAU,EAAC,MAAM,CAAA;CAAC;AACvH,qBAAa,aAAa;IAAa,OAAO,CAAC,OAAO;IAAI,OAAO,CAAC,OAAO;gBAA1B,OAAO,SAAG,EAAS,OAAO,GAAC,OAAO,KAAW;YAAiB,IAAI;IAA+R,MAAM,CAAC,QAAQ,EAAC,eAAe;IAA4F,IAAI,CAAC,aAAa,EAAC,MAAM;kBAA6B,OAAO,EAAE;;IAAuE,GAAG,CAAC,EAAE,EAAC,MAAM;IAAsE,MAAM,CAAC,EAAE,EAAC,MAAM;IAA6F,OAAO,CAAC,EAAE,EAAC,MAAM,EAAC,aAAa,EAAC,MAAM,EAAC,WAAW,EAAC,MAAM;IAA8J,IAAI,CAAC,SAAS,EAAC,MAAM,EAAC,WAAW,EAAC,MAAM,EAAC,cAAc,CAAC,EAAC,MAAM;IAA2J,MAAM,CAAC,IAAI,EAAC,OAAO;IAA2F,MAAM,CAAC,EAAE,EAAC,MAAM;IAAyE,MAAM,CAAC,EAAE,EAAC,MAAM;IAAgF,IAAI,CAAC,EAAE,EAAC,MAAM;CAA+F"}

package/dist/release.js

@@ -0,0 +1,18 @@
+export class ReleaseClient {
+    constructor(baseUrl = '', fetcher = fetch) {
+        this.baseUrl = baseUrl;
+        this.fetcher = fetcher;
+    }
+    async json(path, init) { const r = await this.fetcher(`${this.baseUrl}${path}`, { credentials: 'include', headers: { 'content-type': 'application/json' }, ...init }); const v = await r.json(); if (!r.ok)
+        throw new Error(v?.error || `Release request failed (${r.status})`); return v; }
+    create(manifest) { return this.json('/v1/releases', { method: 'POST', body: JSON.stringify({ manifest }) }); }
+    list(applicationId) { return this.json(`/v1/releases?application_id=${encodeURIComponent(applicationId)}`); }
+    get(id) { return this.json(`/v1/releases/${encodeURIComponent(id)}`); }
+    verify(id) { return this.json(`/v1/releases/${encodeURIComponent(id)}/verify`, { method: 'POST' }); }
+    promote(id, applicationId, environment) { return this.json(`/v1/releases/${encodeURIComponent(id)}/promote`, { method: 'POST', body: JSON.stringify({ application_id: applicationId, environment }) }); }
+    plan(releaseId, environment, rollbackTarget) { return this.json('/v1/deployments/plan', { method: 'POST', body: JSON.stringify({ release_id: releaseId, environment, rollback_target: rollbackTarget }) }); }
+    deploy(plan) { return this.json('/v1/deployments', { method: 'POST', body: JSON.stringify({ plan }) }); }
+    status(id) { return this.json(`/v1/deployments/${encodeURIComponent(id)}`); }
+    health(id) { return this.json(`/v1/deployments/${encodeURIComponent(id)}/health`); }
+    stop(id) { return this.json(`/v1/deployments/${encodeURIComponent(id)}/stop`, { method: 'POST' }); }
+}

package/dist/sharding.d.ts

@@ -0,0 +1,159 @@
+/**
+ * Sharding - Horizontal data partitioning for scaling
+ *
+ * Distributes data across shards for linear scalability:
+ * - Consistent hashing for automatic shard assignment
+ * - Hotspot detection based on metrics
+ * - Automatic rebalancing recommendations
+ * - Multi-shard query support
+ */
+export type ShardingStrategy = 'consistent-hash' | 'range-based' | 'key-modulo';
+export interface ShardKey {
+    field: string;
+    hashFunction: string;
+}
+export interface ShardRange {
+    shardId: string;
+    startHash: number;
+    endHash: number;
+    replicaNodes: string[];
+}
+export interface ShardMetrics {
+    shardId: string;
+    entryCount: number;
+    sizeBytes: number;
+    reads: number;
+    writes: number;
+    avgQueryTimeMs: number;
+}
+export interface HotspotAlert {
+    shardId: string;
+    reason: string;
+    metricValue: number;
+    threshold: number;
+    severity: 'low' | 'medium' | 'high';
+}
+export interface RebalanceOperation {
+    sourceShard: string;
+    targetShard: string;
+    keyRangeStart: number;
+    keyRangeEnd: number;
+    estimatedRecords: number;
+    priority: number;
+}
+export interface ShardDistributionSummary {
+    numShards: number;
+    totalEntries: number;
+    totalSizeBytes: number;
+    totalReads: number;
+    totalWrites: number;
+    maxEntriesPerShard: number;
+    minEntriesPerShard: number;
+    imbalanceRatio: number;
+}
+/**
+ * Shard Manager - TypeScript implementation
+ */
+export declare class ShardManager {
+    private shardingKey;
+    private strategy;
+    private shardRanges;
+    private shardMetrics;
+    private rebalanceHistory;
+    private rebalanceThreshold;
+    constructor(shardingKey: ShardKey, strategy?: ShardingStrategy);
+    /**
+     * Hash a value using simple algorithm
+     */
+    private hashValue;
+    /**
+     * Initialize shards
+     */
+    initializeShards(shardIds: string[], replicaNodes?: Record<string, string[]>): void;
+    /**
+     * Get shard for a key
+     */
+    getShardForKey(key: string): ShardRange | null;
+    /**
+     * Get replica nodes for a key
+     */
+    getReplicasForKey(key: string): string[];
+    /**
+     * Record a shard operation
+     */
+    recordShardOperation(shardId: string, operation: 'read' | 'write' | 'delete', timeMs: number, recordsAffected: number, sizeBytes: number): void;
+    /**
+     * Get all shard metrics
+     */
+    getAllMetrics(): ShardMetrics[];
+    /**
+     * Detect hotspots
+     */
+    detectHotspots(): HotspotAlert[];
+    /**
+     * Generate rebalance operations
+     */
+    generateRebalanceOps(): RebalanceOperation[];
+    /**
+     * Get distribution summary
+     */
+    getDistributionSummary(): ShardDistributionSummary;
+    /**
+     * Record a rebalance operation
+     */
+    recordRebalance(operation: RebalanceOperation): void;
+    /**
+     * Get rebalance history
+     */
+    getRebalanceHistory(): RebalanceOperation[];
+    /**
+     * Calculate standard deviation
+     */
+    private calculateStdDev;
+}
+/**
+ * Shard Router - Routes queries to appropriate shards
+ */
+export declare class ShardRouter {
+    private shardManager;
+    private shardConnections;
+    constructor(shardManager: ShardManager);
+    /**
+     * Route a query to appropriate shards
+     */
+    routeQuery(key: string): string[];
+    /**
+     * Route a range query to multiple shards
+     */
+    routeRangeQuery(keyPattern: string): string[];
+    /**
+     * Register shard connection
+     */
+    registerShardConnection(shardId: string, connection: any): void;
+    /**
+     * Get shard connection
+     */
+    getShardConnection(shardId: string): any;
+}
+/**
+ * Rebalancer - Coordinates data migration between shards
+ */
+export declare class Rebalancer {
+    private shardManager;
+    private shardRouter;
+    private rebalanceInProgress;
+    constructor(shardManager: ShardManager, shardRouter: ShardRouter);
+    /**
+     * Start automatic rebalancing
+     */
+    startAutoRebalance(intervalMs?: number): Promise<void>;
+    /**
+     * Perform rebalancing
+     */
+    performRebalance(): Promise<void>;
+    /**
+     * Check if rebalancing is needed
+     */
+    isRebalanceNeeded(): boolean;
+}
+//# sourceMappingURL=sharding.d.ts.map

package/dist/sharding.d.ts.map

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