@plures/pluresdb 1.6.10 → 2.9.6

package/legacy/benchmarks/memory-benchmarks.ts

@@ -1,350 +0,0 @@
-#!/usr/bin/env -S deno run -A
-
-import { GunDB } from "../core/database.ts";
-
-interface MemoryMetrics {
-  operation: string;
-  initialMemory: number;
-  finalMemory: number;
-  memoryIncrease: number;
-  recordCount: number;
-  memoryPerRecord: number;
-}
-
-class MemoryBenchmark {
-  private results: MemoryMetrics[] = [];
-
-  private getMemoryUsage(): number {
-    return (performance as any).memory?.usedJSHeapSize || 0;
-  }
-
-  async measureMemoryUsage(
-    operation: string,
-    recordCount: number,
-    operationFn: () => Promise<void>,
-  ): Promise<MemoryMetrics> {
-    console.log(`Measuring memory usage for: ${operation}`);
-
-    // Force garbage collection if available
-    if ((globalThis as any).gc) {
-      (globalThis as any).gc();
-    }
-
-    const initialMemory = this.getMemoryUsage();
-
-    await operationFn();
-
-    // Force garbage collection if available
-    if ((globalThis as any).gc) {
-      (globalThis as any).gc();
-    }
-
-    const finalMemory = this.getMemoryUsage();
-    const memoryIncrease = finalMemory - initialMemory;
-    const memoryPerRecord = memoryIncrease / recordCount;
-
-    const metrics: MemoryMetrics = {
-      operation,
-      initialMemory,
-      finalMemory,
-      memoryIncrease,
-      recordCount,
-      memoryPerRecord,
-    };
-
-    this.results.push(metrics);
-
-    console.log(
-      `  Initial Memory: ${(initialMemory / 1024 / 1024).toFixed(2)}MB`,
-    );
-    console.log(`  Final Memory: ${(finalMemory / 1024 / 1024).toFixed(2)}MB`);
-    console.log(
-      `  Memory Increase: ${(memoryIncrease / 1024 / 1024).toFixed(2)}MB`,
-    );
-    console.log(`  Memory per Record: ${memoryPerRecord.toFixed(2)} bytes`);
-    console.log();
-
-    return metrics;
-  }
-
-  printSummary() {
-    console.log("\n" + "=".repeat(80));
-    console.log("MEMORY USAGE SUMMARY");
-    console.log("=".repeat(80));
-
-    this.results.forEach((result) => {
-      console.log(`${result.operation}:`);
-      console.log(`  Records: ${result.recordCount.toLocaleString()}`);
-      console.log(
-        `  Memory Increase: ${
-          (result.memoryIncrease / 1024 / 1024).toFixed(2)
-        }MB`,
-      );
-      console.log(
-        `  Memory per Record: ${result.memoryPerRecord.toFixed(2)} bytes`,
-      );
-      console.log();
-    });
-  }
-}
-
-async function runMemoryBenchmarks() {
-  const benchmark = new MemoryBenchmark();
-  const db = new GunDB();
-
-  try {
-    const kvPath = await Deno.makeTempFile({
-      prefix: "kv_",
-      suffix: ".sqlite",
-    });
-    await db.ready(kvPath);
-
-    console.log("Starting Memory Benchmarks...\n");
-
-    // Benchmark 1: Small Records
-    await benchmark.measureMemoryUsage(
-      "Small Records (100 bytes)",
-      1000,
-      async () => {
-        for (let i = 0; i < 1000; i++) {
-          await db.put(`small:${i}`, {
-            id: i,
-            data: "x".repeat(100),
-            timestamp: Date.now(),
-          });
-        }
-      },
-    );
-
-    // Benchmark 2: Medium Records
-    await benchmark.measureMemoryUsage(
-      "Medium Records (1KB)",
-      1000,
-      async () => {
-        for (let i = 0; i < 1000; i++) {
-          await db.put(`medium:${i}`, {
-            id: i,
-            data: "x".repeat(1024),
-            timestamp: Date.now(),
-            metadata: { size: "medium", type: "test" },
-          });
-        }
-      },
-    );
-
-    // Benchmark 3: Large Records
-    await benchmark.measureMemoryUsage(
-      "Large Records (10KB)",
-      100,
-      async () => {
-        for (let i = 0; i < 100; i++) {
-          await db.put(`large:${i}`, {
-            id: i,
-            data: "x".repeat(10 * 1024),
-            timestamp: Date.now(),
-            metadata: { size: "large", type: "test" },
-            additional: "y".repeat(1024),
-          });
-        }
-      },
-    );
-
-    // Benchmark 4: Vector Data
-    await benchmark.measureMemoryUsage(
-      "Vector Data (100 dimensions)",
-      500,
-      async () => {
-        for (let i = 0; i < 500; i++) {
-          const vector = Array.from({ length: 100 }, () => Math.random());
-          await db.put(`vector:${i}`, {
-            id: i,
-            text: `Document ${i} with vector data`,
-            vector: vector,
-            timestamp: Date.now(),
-          });
-        }
-      },
-    );
-
-    // Benchmark 5: Nested Objects
-    await benchmark.measureMemoryUsage("Nested Objects", 500, async () => {
-      for (let i = 0; i < 500; i++) {
-        await db.put(`nested:${i}`, {
-          id: i,
-          user: {
-            name: `User ${i}`,
-            email: `user${i}@example.com`,
-            profile: {
-              age: 20 + (i % 50),
-              location: `City ${i}`,
-              preferences: {
-                theme: i % 2 === 0 ? "dark" : "light",
-                notifications: true,
-                privacy: "public",
-              },
-            },
-          },
-          metadata: {
-            created: Date.now(),
-            updated: Date.now(),
-            version: 1,
-          },
-        });
-      }
-    });
-
-    // Benchmark 6: Subscriptions Memory Usage
-    await benchmark.measureMemoryUsage("Subscriptions", 1000, async () => {
-      const subscriptions: Array<() => void> = [];
-      for (let i = 0; i < 1000; i++) {
-        const unsubscribe = db.on(`sub:${i}`, () => {});
-        subscriptions.push(unsubscribe);
-      }
-
-      // Store subscriptions for cleanup
-      (globalThis as any).subscriptions = subscriptions;
-    });
-
-    // Clean up subscriptions
-    if ((globalThis as any).subscriptions) {
-      ((globalThis as any).subscriptions as Array<() => void>).forEach((
-        unsubscribe,
-      ) => unsubscribe());
-      delete (globalThis as any).subscriptions;
-    }
-
-    // Benchmark 7: Type System Memory Usage
-    await benchmark.measureMemoryUsage("Type System", 1000, async () => {
-      for (let i = 0; i < 1000; i++) {
-        await db.put(`type:${i}`, { name: `Item ${i}` });
-        await db.setType(`type:${i}`, "TestItem");
-      }
-    });
-
-    // Benchmark 8: CRDT Operations Memory Usage
-    await benchmark.measureMemoryUsage("CRDT Operations", 1000, async () => {
-      for (let i = 0; i < 1000; i++) {
-        await db.put(`crdt:${i}`, {
-          value: i,
-          timestamp: Date.now(),
-          vectorClock: { peer1: i, peer2: i * 2 },
-        });
-      }
-    });
-
-    benchmark.printSummary();
-  } finally {
-    await db.close();
-  }
-}
-
-async function runMemoryLeakTests() {
-  console.log("\n" + "=".repeat(80));
-  console.log("MEMORY LEAK TESTS");
-  console.log("=".repeat(80));
-
-  const db = new GunDB();
-  try {
-    const kvPath = await Deno.makeTempFile({
-      prefix: "kv_",
-      suffix: ".sqlite",
-    });
-    await db.ready(kvPath);
-
-    // Test 1: Subscription Memory Leaks
-    console.log("Testing subscription memory leaks...");
-
-    const initialMemory = (performance as any).memory?.usedJSHeapSize || 0;
-
-    // Create and destroy many subscriptions
-    for (let cycle = 0; cycle < 10; cycle++) {
-      const subscriptions: Array<() => void> = [];
-
-      for (let i = 0; i < 100; i++) {
-        subscriptions.push(db.on(`leak:${cycle}:${i}`, () => {}));
-      }
-
-      // Destroy all subscriptions
-      subscriptions.forEach((unsubscribe) => unsubscribe());
-
-      // Force garbage collection if available
-      if ((globalThis as any).gc) {
-        (globalThis as any).gc();
-      }
-    }
-
-    const finalMemory = (performance as any).memory?.usedJSHeapSize || 0;
-    const memoryIncrease = finalMemory - initialMemory;
-
-    console.log(
-      `Memory increase after subscription cycles: ${
-        (memoryIncrease / 1024).toFixed(2)
-      }KB`,
-    );
-
-    if (memoryIncrease > 1024 * 1024) {
-      // More than 1MB
-      console.log("⚠️  Potential memory leak detected in subscriptions");
-    } else {
-      console.log("✓ No significant memory leak in subscriptions");
-    }
-
-    // Test 2: CRUD Operations Memory Leaks
-    console.log("\nTesting CRUD operations memory leaks...");
-
-    const crudInitialMemory = (performance as any).memory?.usedJSHeapSize || 0;
-
-    // Perform many CRUD operations
-    for (let cycle = 0; cycle < 100; cycle++) {
-      for (let i = 0; i < 100; i++) {
-        await db.put(`leak:${cycle}:${i}`, {
-          data: `Cycle ${cycle} Item ${i}`,
-        });
-        await db.get(`leak:${cycle}:${i}`);
-        await db.delete(`leak:${cycle}:${i}`);
-      }
-
-      // Force garbage collection if available
-      if ((globalThis as any).gc) {
-        (globalThis as any).gc();
-      }
-    }
-
-    const crudFinalMemory = (performance as any).memory?.usedJSHeapSize || 0;
-    const crudMemoryIncrease = crudFinalMemory - crudInitialMemory;
-
-    console.log(
-      `Memory increase after CRUD cycles: ${
-        (crudMemoryIncrease / 1024).toFixed(2)
-      }KB`,
-    );
-
-    if (crudMemoryIncrease > 1024 * 1024) {
-      // More than 1MB
-      console.log("⚠️  Potential memory leak detected in CRUD operations");
-    } else {
-      console.log("✓ No significant memory leak in CRUD operations");
-    }
-  } finally {
-    await db.close();
-  }
-}
-
-async function main() {
-  console.log("PluresDB Memory Benchmarks");
-  console.log("===========================\n");
-
-  try {
-    await runMemoryBenchmarks();
-    await runMemoryLeakTests();
-
-    console.log("\nMemory benchmarks completed successfully!");
-  } catch (error) {
-    console.error("Memory benchmark failed:", error);
-    Deno.exit(1);
-  }
-}
-
-if (import.meta.main) {
-  await main();
-}

package/legacy/benchmarks/run-benchmarks.ts

@@ -1,315 +0,0 @@
-#!/usr/bin/env -S deno run -A
-
-import { GunDB } from "../core/database.ts";
-
-interface BenchmarkResult {
-  name: string;
-  operations: number;
-  totalTime: number;
-  averageTime: number;
-  operationsPerSecond: number;
-  memoryUsage?: number;
-}
-
-class BenchmarkRunner {
-  private results: BenchmarkResult[] = [];
-
-  async runBenchmark(
-    name: string,
-    operations: number,
-    operation: () => Promise<void>,
-  ): Promise<BenchmarkResult> {
-    console.log(`Running benchmark: ${name} (${operations} operations)`);
-
-    const startTime = performance.now();
-    const startMemory = (performance as any).memory?.usedJSHeapSize || 0;
-
-    for (let i = 0; i < operations; i++) {
-      await operation();
-    }
-
-    const endTime = performance.now();
-    const endMemory = (performance as any).memory?.usedJSHeapSize || 0;
-
-    const totalTime = endTime - startTime;
-    const averageTime = totalTime / operations;
-    const operationsPerSecond = (operations / totalTime) * 1000;
-    const memoryUsage = endMemory - startMemory;
-
-    const result: BenchmarkResult = {
-      name,
-      operations,
-      totalTime,
-      averageTime,
-      operationsPerSecond,
-      memoryUsage,
-    };
-
-    this.results.push(result);
-    console.log(
-      `  ✓ ${operationsPerSecond.toFixed(2)} ops/sec (${
-        averageTime.toFixed(2)
-      }ms avg)`,
-    );
-
-    return result;
-  }
-
-  printSummary() {
-    console.log("\n" + "=".repeat(80));
-    console.log("BENCHMARK SUMMARY");
-    console.log("=".repeat(80));
-
-    this.results.forEach((result) => {
-      console.log(`${result.name}:`);
-      console.log(`  Operations: ${result.operations.toLocaleString()}`);
-      console.log(`  Total Time: ${result.totalTime.toFixed(2)}ms`);
-      console.log(`  Average Time: ${result.averageTime.toFixed(2)}ms`);
-      console.log(`  Operations/sec: ${result.operationsPerSecond.toFixed(2)}`);
-      if (result.memoryUsage) {
-        console.log(
-          `  Memory Usage: ${(result.memoryUsage / 1024 / 1024).toFixed(2)}MB`,
-        );
-      }
-      console.log();
-    });
-  }
-}
-
-async function runCoreBenchmarks() {
-  const runner = new BenchmarkRunner();
-  const db = new GunDB();
-
-  try {
-    const kvPath = await Deno.makeTempFile({
-      prefix: "kv_",
-      suffix: ".sqlite",
-    });
-    await db.ready(kvPath);
-
-    console.log("Starting Core Database Benchmarks...\n");
-
-    // Benchmark 1: Basic CRUD Operations
-    await runner.runBenchmark("Basic CRUD Operations", 1000, async () => {
-      const id = `crud:${Math.random()}`;
-      await db.put(id, { value: Math.random(), timestamp: Date.now() });
-      await db.get(id);
-      await db.delete(id);
-    });
-
-    // Benchmark 2: Bulk Insert
-    await runner.runBenchmark("Bulk Insert", 5000, async () => {
-      const id = `bulk:${Math.random()}`;
-      await db.put(id, {
-        data: "x".repeat(100),
-        timestamp: Date.now(),
-        random: Math.random(),
-      });
-    });
-
-    // Benchmark 3: Bulk Read
-    // First populate with data
-    for (let i = 0; i < 1000; i++) {
-      await db.put(`read:${i}`, { value: i, data: `Data ${i}` });
-    }
-
-    let readCount = 0;
-    await runner.runBenchmark("Bulk Read", 1000, async () => {
-      await db.get(`read:${readCount % 1000}`);
-      readCount++;
-    });
-
-    // Benchmark 4: Vector Search
-    // First populate with documents
-    for (let i = 0; i < 100; i++) {
-      await db.put(`doc:${i}`, {
-        text:
-          `Document ${i} about machine learning and artificial intelligence`,
-        content:
-          `This is document number ${i} containing information about AI and ML algorithms`,
-      });
-    }
-
-    const searchQueries = [
-      "machine learning",
-      "artificial intelligence",
-      "neural networks",
-      "deep learning",
-      "data science",
-    ];
-
-    let queryCount = 0;
-    await runner.runBenchmark("Vector Search", 100, async () => {
-      const query = searchQueries[queryCount % searchQueries.length];
-      await db.vectorSearch(query, 10);
-      queryCount++;
-    });
-
-    // Benchmark 5: Subscription Performance
-    const subscriptions: Array<() => void> = [];
-    for (let i = 0; i < 100; i++) {
-      subscriptions.push(db.on(`sub:${i}`, () => {}));
-    }
-
-    let updateCount = 0;
-    await runner.runBenchmark("Subscription Updates", 500, async () => {
-      await db.put(`sub:${updateCount % 100}`, {
-        update: updateCount,
-        timestamp: Date.now(),
-      });
-      updateCount++;
-    });
-
-    // Clean up subscriptions
-    subscriptions.forEach((unsubscribe) => unsubscribe());
-
-    // Benchmark 6: Type System Operations
-    await runner.runBenchmark("Type System Operations", 1000, async () => {
-      const id = `type:${Math.random()}`;
-      await db.put(id, { name: `Item ${Math.random()}` });
-      await db.setType(id, "TestItem");
-      await db.instancesOf("TestItem");
-    });
-
-    runner.printSummary();
-  } finally {
-    await db.close();
-  }
-}
-
-async function runNetworkBenchmarks() {
-  const runner = new BenchmarkRunner();
-
-  console.log("Starting Network Benchmarks...\n");
-
-  // Benchmark 1: WebSocket Connection Performance
-  const db = new GunDB();
-  try {
-    const kvPath = await Deno.makeTempFile({
-      prefix: "kv_",
-      suffix: ".sqlite",
-    });
-    await db.ready(kvPath);
-
-    const port = 18000 + Math.floor(Math.random() * 10000);
-    await db.serve({ port });
-
-    const serverUrl = `ws://localhost:${port}`;
-
-    await runner.runBenchmark("WebSocket Connections", 10, async () => {
-      const clientDb = new GunDB();
-      const clientKv = await Deno.makeTempFile({
-        prefix: "kv_client_",
-        suffix: ".sqlite",
-      });
-      await clientDb.ready(clientKv);
-
-      const connectionPromise = new Promise<void>((resolve, reject) => {
-        const ws = new WebSocket(serverUrl);
-        ws.onopen = () => {
-          ws.close();
-          resolve();
-        };
-        ws.onerror = reject;
-        setTimeout(() => reject(new Error("Connection timeout")), 5000);
-      });
-
-      await connectionPromise;
-      await clientDb.close();
-    });
-  } finally {
-    await db.close();
-  }
-
-  runner.printSummary();
-}
-
-async function runMemoryBenchmarks() {
-  const runner = new BenchmarkRunner();
-  const db = new GunDB();
-
-  try {
-    const kvPath = await Deno.makeTempFile({
-      prefix: "kv_",
-      suffix: ".sqlite",
-    });
-    await db.ready(kvPath);
-
-    console.log("Starting Memory Benchmarks...\n");
-
-    // Benchmark 1: Memory Usage with Large Datasets
-    const initialMemory = (performance as any).memory?.usedJSHeapSize || 0;
-
-    await runner.runBenchmark("Large Dataset Memory Usage", 1000, async () => {
-      const id = `memory:${Math.random()}`;
-      await db.put(id, {
-        data: "x".repeat(1024), // 1KB per record
-        timestamp: Date.now(),
-        random: Math.random(),
-      });
-    });
-
-    const finalMemory = (performance as any).memory?.usedJSHeapSize || 0;
-    const memoryIncrease = finalMemory - initialMemory;
-
-    console.log(
-      `Memory Usage: ${
-        (memoryIncrease / 1024 / 1024).toFixed(2)
-      }MB for 1000 records`,
-    );
-    console.log(
-      `Memory per record: ${(memoryIncrease / 1000).toFixed(2)} bytes`,
-    );
-
-    // Benchmark 2: Subscription Memory Usage
-    const subscriptionMemory = (performance as any).memory?.usedJSHeapSize || 0;
-
-    const subscriptions: Array<() => void> = [];
-    await runner.runBenchmark("Subscription Memory Usage", 1000, async () => {
-      const id = `sub:${Math.random()}`;
-      const unsubscribe = db.on(id, () => {});
-      subscriptions.push(unsubscribe);
-    });
-
-    const afterSubscriptionMemory =
-      (performance as any).memory?.usedJSHeapSize || 0;
-    const subscriptionMemoryIncrease = afterSubscriptionMemory -
-      subscriptionMemory;
-
-    console.log(
-      `Subscription Memory: ${
-        (subscriptionMemoryIncrease / 1024).toFixed(2)
-      }KB for 1000 subscriptions`,
-    );
-    console.log(
-      `Memory per subscription: ${
-        (subscriptionMemoryIncrease / 1000).toFixed(2)
-      } bytes`,
-    );
-
-    // Clean up subscriptions
-    subscriptions.forEach((unsubscribe) => unsubscribe());
-  } finally {
-    await db.close();
-  }
-}
-
-async function main() {
-  console.log("PluresDB Benchmark Suite");
-  console.log("========================\n");
-
-  try {
-    await runCoreBenchmarks();
-    await runNetworkBenchmarks();
-    await runMemoryBenchmarks();
-
-    console.log("All benchmarks completed successfully!");
-  } catch (error) {
-    console.error("Benchmark failed:", error);
-    Deno.exit(1);
-  }
-}
-
-if (import.meta.main) {
-  await main();
-}