mindoodb 0.0.2 → 0.0.4

package/dist/node/appendonlystores/BasicOnDiskContentAddressedStore.d.ts

@@ -0,0 +1,544 @@
+/**
+ * Node.js filesystem-backed implementation of {@link ContentAddressedStore}.
+ *
+ * This module provides a persistent, crash-resilient content-addressed store
+ * designed for the MindooDB sync protocol.  Each database gets its own
+ * directory subtree where entry metadata (JSON) and encrypted payloads (binary)
+ * are stored as individual files.  An optional in-memory index accelerates
+ * lookups, cursor-based scans, and bloom-filter generation for efficient
+ * network sync.
+ *
+ * ### On-disk layout
+ *
+ * ```
+ * <basePath>/<dbId>/
+ *   entries/                  one JSON file per entry id (source of truth)
+ *   content/                  one .bin file per unique contentHash
+ *   metadata-index.json       compact snapshot of the in-memory index
+ *   metadata-segments/        append-only mutation log (upsert / delete)
+ * ```
+ *
+ * ### Durability & crash safety
+ *
+ * Every file write follows a write-tmp → fsync → atomic-rename → dir-fsync
+ * protocol so readers never observe partially written data.  Metadata segments
+ * provide a low-write-amplification WAL that is periodically compacted into a
+ * full snapshot.
+ *
+ * ### Indexing
+ *
+ * When `indexingEnabled` is true (the default), the store maintains three
+ * in-memory structures:
+ *   - `entries` — Map<id, metadata> for O(1) point lookups
+ *   - `docIndex` — Map<docId, Set<id>> for fast per-document queries
+ *   - `orderedMetadata` — sorted array for O(log N) cursor scans
+ *
+ * On startup the index is reconstructed from (snapshot + segments), then
+ * validated against the authoritative entry files.
+ *
+ * @module BasicOnDiskContentAddressedStore
+ */
+import { ContentAddressedStore, ContentAddressedStoreFactory, CreateStoreResult, DocumentMaterializationBatchPlan, DocumentMaterializationPlan, MaterializationPlanOptions, OpenStoreOptions, StoreIndexBuildStatus, StoreCompactionStatus, AwaitIndexReadyOptions, StoreScanCursor, StoreScanFilters, StoreScanResult, StoreIdBloomSummary } from "../../core/appendonlystores/types";
+import type { StoreEntry, StoreEntryMetadata, StoreEntryType } from "../../core/types";
+import { Logger } from "../../core/logging";
+/**
+ * Node.js persistent ContentAddressedStore implementation.
+ *
+ * On-disk layout per database id:
+ *
+ *   <basePath>/<dbId>/
+ *     entries/                // one metadata JSON file per entry id
+ *     content/                // one binary payload file per contentHash
+ *     metadata-index.json     // compact snapshot of ordered metadata (optional)
+ *     metadata-segments/      // append-only metadata mutation log (optional)
+ *
+ * Design goals:
+ * - Strong visibility: readers only observe committed files (atomic rename).
+ * - Crash resilience: fsync + rename + directory fsync for durability.
+ * - High sync/read throughput: in-memory ordered index + cursor scan.
+ * - Low write amplification: append metadata segments, compact periodically.
+ */
+export declare class BasicOnDiskContentAddressedStore implements ContentAddressedStore {
+    /** Unique database identifier; used as the top-level directory name. */
+    private readonly dbId;
+    /** Logger scoped to this store instance. */
+    private readonly logger;
+    /** Root directory for this database: `<basePath>/<dbId>`. */
+    private readonly storeRoot;
+    /** Directory containing one JSON metadata file per entry id. */
+    private readonly entriesDir;
+    /** Directory containing one `.bin` payload file per unique contentHash. */
+    private readonly contentDir;
+    /** Path to the compact metadata-index snapshot file. */
+    private readonly metadataIndexPath;
+    /** Directory containing append-only metadata segment files. */
+    private readonly metadataSegmentsDir;
+    /** Whether in-memory indexing is active (default true). */
+    private readonly indexingEnabled;
+    /** Trigger compaction when this many segment files have accumulated. */
+    private readonly metadataSegmentCompactionMinFiles;
+    /** Trigger compaction when segment files exceed this total byte size. */
+    private readonly metadataSegmentCompactionMaxBytes;
+    /**
+     * Set of segment file names that have been replayed into the in-memory
+     * index (or were appended by this process).  Only these files are eligible
+     * for compaction — files that appeared concurrently from another process
+     * are excluded until they have been replayed.
+     */
+    private readonly appliedMetadataSegmentFiles;
+    /** Cumulative compaction statistics exposed via {@link getCompactionStatus}. */
+    private compactionStatus;
+    /**
+     * Resolves once the store directories exist and the in-memory index has been
+     * built.  Every public method awaits this promise before proceeding.
+     */
+    private initPromise;
+    /**
+     * Primary index: entry id -> full metadata.
+     * Provides O(1) point lookups for `hasEntries`, `getEntries`,
+     * `readMetadataById`, and dependency traversal.
+     */
+    private entries;
+    /**
+     * Secondary index: docId -> set of entry ids belonging to that document.
+     * Enables fast per-document queries in `findNewEntriesForDoc`.
+     */
+    private docIndex;
+    /**
+     * Reference count per content hash.  Tracks how many entry ids share the
+     * same payload blob, used during `purgeDocHistory` to decide whether a
+     * content file can be safely deleted.
+     */
+    private contentRefCount;
+    /**
+     * All metadata sorted by `(createdAt ASC, id ASC)`.
+     * Supports O(log N) lower-bound binary search for cursor-based scans
+     * in {@link scanEntriesSince}.
+     */
+    private orderedMetadata;
+    /** Current phase and progress of the index build (building / ready). */
+    private indexStatus;
+    /**
+     * Create a new on-disk content-addressed store for the given database id.
+     *
+     * Initialization (directory creation, index loading) happens asynchronously.
+     * All public methods internally await the init promise so callers do not
+     * need to wait explicitly — but {@link awaitIndexReady} can be used to
+     * observe progress.
+     *
+     * @param dbId     Unique database identifier (becomes the directory name).
+     * @param logger   Optional logger; a default console logger is created if omitted.
+     * @param options  Store configuration (base path, indexing, compaction thresholds, etc.).
+     */
+    constructor(dbId: string, logger?: Logger, options?: OpenStoreOptions);
+    /**
+     * One-time async initialization performed in the constructor's microtask.
+     *
+     * Steps:
+     * 1. Optionally wipe all local data (if `clearLocalDataOnStartup`).
+     * 2. Ensure on-disk directory structure exists.
+     * 3. When indexing is enabled:
+     *    a. Attempt to load the persisted metadata-index snapshot (fast path).
+     *    b. Replay any append-only segment files written since the snapshot.
+     *    c. Validate the resulting in-memory index against the authoritative
+     *       entry files on disk.
+     *    d. If validation fails (stale snapshot, corruption, etc.), do a full
+     *       rebuild from the entry files and write a fresh snapshot.
+     */
+    private initialize;
+    /** Block until async initialization has completed. Called by every public method. */
+    private ensureInitialized;
+    /**
+     * Unconditionally remove the entire store directory tree and reset all
+     * in-memory state.  Called by the constructor when `clearLocalDataOnStartup`
+     * is set, and by {@link clearAllLocalData} at runtime.
+     */
+    private clearAllLocalDataInternal;
+    /**
+     * Full index rebuild from the authoritative entry files on disk.
+     *
+     * Clears all in-memory structures, reads every `entries/*.json` file,
+     * populates the primary, secondary, and ref-count indexes, and finally
+     * sorts `orderedMetadata` by `(createdAt, id)`.
+     *
+     * This is the slowest startup path (O(N) filesystem reads) and is only
+     * used when the persisted snapshot + segments cannot be validated.
+     */
+    private rebuildInMemoryIndexes;
+    /**
+     * Attempt to hydrate the in-memory index from the persisted
+     * `metadata-index.json` snapshot.
+     *
+     * This is the fast startup path: a single file read replaces the need to
+     * enumerate and parse every individual entry file.
+     *
+     * @returns `true` if the snapshot was loaded successfully; `false` if it
+     *          does not exist or could not be parsed (caller should fall back
+     *          to a full rebuild).
+     */
+    private tryLoadPersistedIndex;
+    /**
+     * Validate that the in-memory index (loaded from snapshot + segments)
+     * is consistent with the authoritative entry files on disk.
+     *
+     * Checks two invariants:
+     * 1. The number of entry files matches `this.entries.size`.
+     * 2. Every entry file's id exists in the in-memory map.
+     *
+     * This is a cheap O(N) directory listing + set-membership check (no file
+     * reads) that catches stale snapshots, missing segments, and external
+     * mutations that happened while the process was down.
+     *
+     * @returns `true` if the index fully covers the on-disk entries.
+     */
+    private validatePersistedIndexCoverage;
+    /**
+     * Write a full metadata-index snapshot to disk.
+     *
+     * Serializes the entire `orderedMetadata` array to `metadata-index.json`
+     * using an atomic write.  After this, all segment files that have been
+     * replayed into the in-memory state are redundant and can be deleted.
+     */
+    private persistMetadataIndex;
+    /**
+     * Delete the given segment files from disk and remove them from the
+     * `appliedMetadataSegmentFiles` tracking set.
+     *
+     * Deletion failures (e.g. race with another process) are silently ignored.
+     */
+    private clearMetadataSegments;
+    /**
+     * List all `.json` segment files in the segments directory, sorted
+     * lexicographically.  Since segment filenames are prefixed with a
+     * millisecond timestamp, lexicographic order approximates chronological
+     * append order.
+     */
+    private listMetadataSegmentFiles;
+    /**
+     * Replay all segment files into the in-memory index.
+     *
+     * Each segment file contains a JSON array of upsert/delete records.
+     * They are applied in lexicographic filename order (≈ chronological order)
+     * on top of whatever state the snapshot already provided.
+     *
+     * Successfully replayed files are tracked in `appliedMetadataSegmentFiles`
+     * so they become eligible for compaction.  Corrupt or unreadable segment
+     * files are warned about and skipped — the subsequent
+     * {@link validatePersistedIndexCoverage} step will catch any resulting
+     * inconsistencies.
+     */
+    private replayMetadataSegments;
+    /**
+     * Append a new segment file containing the given mutation records.
+     *
+     * Segment files act as a lightweight write-ahead log: rather than
+     * rewriting the entire metadata-index snapshot on every mutation, we
+     * append a small file.  This keeps per-write I/O proportional to the
+     * batch size rather than total store size.
+     *
+     * After writing, triggers {@link maybeCompactMetadataSegments} to check
+     * whether the accumulated segments should be folded into a fresh snapshot.
+     */
+    private appendMetadataSegment;
+    /**
+     * Conditionally compact metadata segments when a threshold is exceeded.
+     *
+     * Two independent thresholds can trigger compaction:
+     * - **File count**: the number of applied segment files ≥
+     *   `metadataSegmentCompactionMinFiles`.
+     * - **Total bytes**: the cumulative size of applied segment files ≥
+     *   `metadataSegmentCompactionMaxBytes`.
+     *
+     * Compaction writes a fresh metadata-index snapshot (which already
+     * includes all replayed segment data) and then deletes the covered
+     * segment files.  Only files tracked in `appliedMetadataSegmentFiles`
+     * are compacted — files written concurrently by another process are
+     * left untouched.
+     *
+     * Compaction statistics are accumulated in `this.compactionStatus`.
+     */
+    private maybeCompactMetadataSegments;
+    /**
+     * Sum the on-disk sizes of the given segment files.
+     * Used to evaluate the byte-based compaction threshold.
+     * Files that have been deleted between listing and stat are silently skipped.
+     */
+    private computeSegmentFilesTotalBytes;
+    /**
+     * Compare two metadata entries by the canonical sort key `(createdAt, id)`.
+     * Used to maintain and query the `orderedMetadata` sorted array.
+     */
+    private compareMetadata;
+    /**
+     * Binary search for the first index in `orderedMetadata` that is strictly
+     * greater than the given cursor position `(createdAt, id)`.
+     *
+     * Returns 0 when cursor is `null` (start from the beginning).
+     * Runs in O(log N) time.
+     */
+    private lowerBoundForCursor;
+    /**
+     * Test whether a metadata entry passes the given scan filters.
+     * Evaluates docId, entryTypes whitelist, and creationDate range.
+     * Returns `true` when no filters are provided or all checks pass.
+     */
+    private metadataMatchesFilters;
+    /**
+     * Insert a metadata entry into `orderedMetadata` at the correct sorted
+     * position using binary search + splice.  O(log N) search + O(N) splice.
+     */
+    private insertOrderedMetadata;
+    /**
+     * Remove an entry from `orderedMetadata` by id.
+     * Uses a linear scan; acceptable because removals (purge) are rare.
+     */
+    private removeOrderedMetadataById;
+    /**
+     * Remove an entry from all in-memory indexes.
+     *
+     * Updates `entries`, `docIndex`, `orderedMetadata`, and `contentRefCount`.
+     * When the content hash reference count drops to zero, the hash is removed
+     * from the ref-count map (the caller is responsible for deleting the
+     * on-disk content file if needed).
+     */
+    private applyMetadataDelete;
+    /**
+     * Insert or replace an entry in all in-memory indexes.
+     *
+     * If the id already exists, the old entry is removed first (via
+     * {@link applyMetadataDelete}) before the new one is inserted.
+     * Updates `entries`, `docIndex`, `orderedMetadata`, and `contentRefCount`.
+     */
+    private applyMetadataUpsert;
+    /** List all `.json` files in the `entries/` directory. */
+    private listEntryFiles;
+    /** Resolve the absolute path to the metadata file for a given entry id. */
+    private metadataPathForId;
+    /** Resolve the absolute path to the binary content file for a given hash. */
+    private contentPathForHash;
+    /** Check whether a file exists without reading its contents. */
+    private fileExists;
+    /**
+     * Write data to a file with full crash-safety guarantees.
+     *
+     * Protocol:
+     * 1. Write to a temporary file (unique per process + timestamp + random).
+     * 2. `fsync` the temp file to flush OS buffers to disk.
+     * 3. Atomically `rename` temp → final path (POSIX guarantees atomicity).
+     * 4. `fsync` the parent directory so the new directory entry is durable.
+     *
+     * This ensures readers never observe a partially written file, even after
+     * an unclean shutdown.
+     */
+    private writeFileAtomic;
+    /**
+     * Fsync the parent directory of a file to ensure its directory entry
+     * update is persisted.  Required on POSIX systems after rename/unlink
+     * to guarantee that the directory metadata change survives a crash.
+     *
+     * Failures are logged at debug level and swallowed — some platforms
+     * (e.g. certain macOS configurations) do not support opening directories
+     * for fsync.
+     */
+    private syncParentDirectory;
+    /**
+     * Look up an entry's metadata by id.
+     *
+     * When indexing is enabled, this is an O(1) in-memory map lookup.
+     * Otherwise, falls back to reading the entry file from disk.
+     *
+     * @returns The metadata if found, or `null`.
+     */
+    private readMetadataById;
+    /**
+     * Read and deserialize a metadata entry directly from its on-disk file.
+     * Used during index rebuilds and non-indexed fallback paths.
+     * Parse failures are logged and result in `null`.
+     */
+    private readMetadataByFileName;
+    /**
+     * Return all metadata entries in the store.
+     *
+     * When indexing is enabled, returns a shallow copy of `orderedMetadata`
+     * (already sorted).  Otherwise, reads and parses every entry file from
+     * disk (unsorted).
+     */
+    private listAllMetadata;
+    /** Return the database id this store was created for. */
+    getId(): string;
+    getCacheIdentity(): string;
+    /**
+     * Persist one or more entries to disk.
+     *
+     * For each entry the method:
+     * 1. Skips if the metadata file already exists (content-addressed idempotency).
+     * 2. Writes the encrypted payload to `content/<hash>.bin` (deduplicated by hash).
+     * 3. Writes the metadata to `entries/<id>.json`.
+     * 4. Updates the in-memory index and appends a segment record.
+     *
+     * The commit order (content → metadata → segment) ensures that a crash at
+     * any point leaves the store in a consistent state: orphaned content blobs
+     * are harmless, and the index can always be rebuilt from the metadata files.
+     */
+    putEntries(entries: StoreEntry[]): Promise<void>;
+    /**
+     * Retrieve full entries (metadata + encrypted payload) by id.
+     *
+     * IDs that are not found or whose content file is missing are silently
+     * omitted from the result.  When indexing is enabled, the metadata lookup
+     * is O(1); the content read is always a disk I/O.
+     */
+    getEntries(ids: string[]): Promise<StoreEntry[]>;
+    /**
+     * Check which of the given ids exist in the store.
+     *
+     * When indexing is enabled, this is a fast in-memory set-membership test.
+     * Otherwise, it checks for the existence of the corresponding metadata
+     * file on disk.
+     *
+     * @returns The subset of `ids` that are present in the store.
+     */
+    hasEntries(ids: string[]): Promise<string[]>;
+    /**
+     * Find all entries whose ids are not in `knownIds`.
+     *
+     * Used during sync to discover entries the caller has not yet seen.
+     * Returns metadata only (no payload).
+     */
+    findNewEntries(knownIds: string[]): Promise<StoreEntryMetadata[]>;
+    /**
+     * Find entries for a specific document that are not in `knownIds`.
+     *
+     * When indexing is enabled, leverages the `docIndex` for an O(K) scan
+     * (K = entries for this doc) instead of the full store.
+     */
+    findNewEntriesForDoc(knownIds: string[], docId: string): Promise<StoreEntryMetadata[]>;
+    /**
+     * Find entries matching a given type and optional creation-date range.
+     *
+     * @param type              Entry type to filter by (e.g. "doc_change").
+     * @param creationDateFrom  Inclusive lower bound (epoch ms), or `null` for no lower bound.
+     * @param creationDateUntil Exclusive upper bound (epoch ms), or `null` for no upper bound.
+     * @returns Metadata of all matching entries.
+     */
+    findEntries(type: StoreEntryType, creationDateFrom: number | null, creationDateUntil: number | null): Promise<StoreEntryMetadata[]>;
+    /**
+     * Return all entry ids in the store.
+     *
+     * When indexing is enabled, returns ids in `(createdAt, id)` order.
+     * Without indexing, order depends on the filesystem directory listing.
+     */
+    getAllIds(): Promise<string[]>;
+    /**
+     * Cursor-based paginated scan over entry metadata.
+     *
+     * Designed for high-volume synchronization: the caller repeatedly advances
+     * a cursor to stream through all entries in deterministic
+     * `(createdAt ASC, id ASC)` order, optionally applying filters.
+     *
+     * **Indexed path** (default):
+     * - O(log N) binary search for the cursor position.
+     * - O(pageSize) slice for unfiltered scans; O(scan window) for filtered.
+     *
+     * **Non-indexed fallback**:
+     * - Reads and sorts *all* metadata on every call.  Suitable only for
+     *   small stores or when indexing is explicitly disabled.
+     *
+     * @param cursor  Position to resume from (exclusive), or `null` to start
+     *                from the beginning.
+     * @param limit   Maximum number of entries to return in this page.
+     * @param filters Optional filters (docId, entryTypes, date range).
+     * @returns A page of metadata entries, the next cursor, and a `hasMore` flag.
+     */
+    scanEntriesSince(cursor: StoreScanCursor | null, limit?: number, filters?: StoreScanFilters): Promise<StoreScanResult>;
+    /**
+     * Build a bloom filter summary of all entry ids in this store.
+     *
+     * The summary is a compact probabilistic set representation that a remote
+     * peer can use during sync to cheaply test which of its own ids are
+     * *definitely absent* from this store — avoiding per-id network
+     * round-trips.  See {@link createIdBloomSummary} for details on the bloom
+     * filter implementation.
+     *
+     * @returns A serializable {@link StoreIdBloomSummary} with a base64-encoded
+     *          bitset, suitable for transmission over the network.
+     */
+    getIdBloomSummary(): Promise<StoreIdBloomSummary>;
+    planDocumentMaterialization(docId: string, options?: MaterializationPlanOptions): Promise<DocumentMaterializationPlan>;
+    planDocumentMaterializationBatch(docIds: string[], options?: MaterializationPlanOptions): Promise<DocumentMaterializationBatchPlan>;
+    /**
+     * Traverse the dependency graph starting from a given entry id.
+     *
+     * Performs a breadth-first traversal through `dependencyIds` links,
+     * collecting all reachable entries.  The result is returned in
+     * **dependency-first order** (deepest dependencies first) so callers
+     * can process entries from oldest to newest.
+     *
+     * Use cases:
+     * - Loading all chunks of a large attachment (traverse from the last
+     *   chunk back to the first).
+     * - Reconstructing a document state by collecting all changes.
+     * - Stopping at snapshots to avoid loading the full history.
+     *
+     * @param startId  The entry id to begin traversal from.
+     * @param options  Optional traversal controls:
+     *   - `stopAtEntryType` — stop expanding when hitting this type (the
+     *     matching entry is still included).
+     *   - `maxDepth` — maximum number of hops from `startId`.
+     *   - `includeStart` — whether `startId` itself appears in the result
+     *     (default `true`).
+     * @returns Entry ids in dependency-first order.
+     */
+    resolveDependencies(startId: string, options?: Record<string, unknown>): Promise<string[]>;
+    /**
+     * Permanently delete all entries belonging to a document (GDPR purge).
+     *
+     * Steps:
+     * 1. Identify all metadata entries with the given `docId`.
+     * 2. Delete each metadata file and update the in-memory index.
+     * 3. Delete orphaned content blobs — content files whose hash is no
+     *    longer referenced by any remaining entry.
+     * 4. Append "delete" segment records so the index stays consistent
+     *    across restarts.
+     *
+     * @param docId  The document whose entire history should be erased.
+     */
+    purgeDocHistory(docId: string): Promise<void>;
+    /**
+     * Delete all data for this database and recreate empty directories.
+     *
+     * Resets the index status to "building" temporarily, removes the entire
+     * store root, and re-creates the directory structure.  The index is
+     * immediately marked "ready" afterwards since the store is now empty.
+     */
+    clearAllLocalData(): Promise<void>;
+    /**
+     * Wait until the in-memory index has finished building and return its
+     * status.  Since initialization is fully awaited via `initPromise`, this
+     * effectively waits for the constructor's async init to complete.
+     */
+    awaitIndexReady(_options?: AwaitIndexReadyOptions): Promise<StoreIndexBuildStatus>;
+    /** Return the current index build status without waiting. */
+    getIndexBuildStatus(): StoreIndexBuildStatus;
+    /** Return a snapshot of cumulative metadata-segment compaction statistics. */
+    getCompactionStatus(): Promise<StoreCompactionStatus>;
+}
+/**
+ * Factory that creates {@link BasicOnDiskContentAddressedStore} instances.
+ *
+ * Implements the {@link ContentAddressedStoreFactory} interface so it can be
+ * plugged into MindooDB's store creation pipeline.  Each call to
+ * `createStore` returns a fresh store backed by its own on-disk directory
+ * under the configured base path.
+ */
+export declare class BasicOnDiskContentAddressedStoreFactory implements ContentAddressedStoreFactory {
+    /**
+     * Create a new on-disk content-addressed store for the given database.
+     *
+     * @param dbId    Unique database identifier (becomes the directory name).
+     * @param options Store configuration forwarded to the constructor.
+     * @returns A {@link CreateStoreResult} containing the new store as `docStore`.
+     */
+    createStore(dbId: string, options?: OpenStoreOptions): CreateStoreResult;
+}
+//# sourceMappingURL=BasicOnDiskContentAddressedStore.d.ts.map

package/dist/node/appendonlystores/BasicOnDiskContentAddressedStore.d.ts.map

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