@j0hanz/memdb 1.2.9 → 1.3.0

package/dist/core/db.js

@@ -92,9 +92,6 @@ const enableDefensiveMode = (database) => {
         extended.enableDefensive(true);
     }
 };
-const isInTransaction = (database) => {
-    return database.isTransaction;
-};
 const initializeSchema = (database) => {
     database.exec(SCHEMA_SQL);
     database.exec(FTS_SYNC_SQL);
@@ -129,44 +126,59 @@ export const getDb = () => {
     }
     return dbInstance;
 };
-export const closeDb = () => {
-    if (dbInstance?.isOpen) {
-        dbInstance.close();
-        dbInstance = undefined;
-        statementCache.clear();
+const MAX_CACHED_STATEMENTS = 200;
+class LruStatementCache {
+    maxSize;
+    cache = new Map();
+    constructor(maxSize) {
+        this.maxSize = maxSize;
+    }
+    get(sql) {
+        const hit = this.cache.get(sql);
+        if (!hit)
+            return undefined;
+        // Refresh LRU order
+        this.cache.delete(sql);
+        this.cache.set(sql, hit);
+        return hit;
+    }
+    set(sql, stmt) {
+        this.cache.set(sql, stmt);
+        if (this.cache.size <= this.maxSize)
+            return;
+        const oldestKey = this.cache.keys().next().value;
+        if (oldestKey)
+            this.cache.delete(oldestKey);
     }
+    clear() {
+        this.cache.clear();
+    }
+}
+const statementCache = new LruStatementCache(MAX_CACHED_STATEMENTS);
+export const closeDb = () => {
+    if (!dbInstance?.isOpen)
+        return;
+    dbInstance.close();
+    dbInstance = undefined;
+    statementCache.clear();
 };
-const MAX_CACHED_STATEMENTS = 200;
-const statementCache = new Map();
 export const prepareCached = (sql) => {
     const cached = statementCache.get(sql);
-    if (cached) {
-        statementCache.delete(sql);
-        statementCache.set(sql, cached);
+    if (cached)
         return cached;
-    }
     const stmt = getDb().prepare(sql);
     statementCache.set(sql, stmt);
-    if (statementCache.size > MAX_CACHED_STATEMENTS) {
-        const oldestKey = statementCache.keys().next().value;
-        if (oldestKey)
-            statementCache.delete(oldestKey);
-    }
     return stmt;
 };
-const isDbRow = (value) => {
-    return typeof value === 'object' && value !== null;
-};
+const isDbRow = (value) => typeof value === 'object' && value !== null;
 const assertDbRow = (value) => {
-    if (!isDbRow(value)) {
+    if (!isDbRow(value))
         throw new Error('Invalid row');
-    }
     return value;
 };
 const toDbRowArray = (value) => {
-    if (!Array.isArray(value)) {
+    if (!Array.isArray(value))
         throw new Error('Expected rows array');
-    }
     return value.map(assertDbRow);
 };
 const toDbRowOrUndefined = (value) => {
@@ -186,12 +198,11 @@ const toRunResult = (value) => {
     return { changes };
 };
 export const executeAll = (stmt, ...params) => toDbRowArray(stmt.all(...params));
-// eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters
 export const executeGet = (stmt, ...params) => toDbRowOrUndefined(stmt.get(...params));
 export const executeRun = (stmt, ...params) => toRunResult(stmt.run(...params));
 export const withImmediateTransaction = (operation) => {
     const db = getDb();
-    if (isInTransaction(db)) {
+    if (db.isTransaction) {
         throw new Error('Cannot start nested transaction');
     }
     db.exec('BEGIN IMMEDIATE');
@@ -205,6 +216,24 @@ export const withImmediateTransaction = (operation) => {
         throw err;
     }
 };
+const SAVEPOINT_NAME_PATTERN = /^[A-Za-z_]\w*$/;
+export const withSavepoint = (name, operation) => {
+    if (!SAVEPOINT_NAME_PATTERN.test(name)) {
+        throw new Error(`Invalid savepoint name: ${name}`);
+    }
+    const db = getDb();
+    db.exec(`SAVEPOINT ${name}`);
+    try {
+        const result = operation();
+        db.exec(`RELEASE ${name}`);
+        return result;
+    }
+    catch (err) {
+        db.exec(`ROLLBACK TO ${name}`);
+        db.exec(`RELEASE ${name}`);
+        throw err;
+    }
+};
 const createFieldError = (field) => new Error(`Invalid ${field}`);
 const assertFiniteNumber = (value, field) => {
     if (!Number.isFinite(value)) {
@@ -233,14 +262,6 @@ const toString = (value, field) => {
         return value;
     throw createFieldError(field);
 };
-const isMemoryType = (value) => MEMORY_TYPES.includes(value);
-const toMemoryType = (value, field) => {
-    const str = toString(value, field);
-    if (!isMemoryType(str)) {
-        throw createFieldError(field);
-    }
-    return str;
-};
 const toOptionalString = (value, field) => {
     if (value === null || value === undefined)
         return undefined;
@@ -251,6 +272,13 @@ const toOptionalNumber = (value, field) => {
         return undefined;
     return toNumber(value, field);
 };
+const isMemoryType = (value) => MEMORY_TYPES.includes(value);
+const toMemoryType = (value, field) => {
+    const str = toString(value, field);
+    if (!isMemoryType(str))
+        throw createFieldError(field);
+    return str;
+};
 export const mapRowToMemory = (row, tags = []) => ({
     id: toSafeInteger(row.id, 'id'),
     content: toString(row.content, 'content'),
@@ -273,6 +301,19 @@ export const mapRowToRelationship = (row) => ({
     relation_type: toString(row.relation_type, 'relation_type'),
     created_at: toString(row.created_at, 'created_at'),
 });
+export const findMemoryIdByHash = (hash) => {
+    const stmt = prepareCached('SELECT id FROM memories WHERE hash = ?');
+    const row = executeGet(stmt, hash);
+    if (!row)
+        return undefined;
+    return toSafeInteger(row.id, 'id');
+};
+export const requireMemoryIdByHash = (hash, message = `Memory not found: ${hash}`) => {
+    const id = findMemoryIdByHash(hash);
+    if (id === undefined)
+        throw new Error(message);
+    return id;
+};
 const dedupeIds = (ids) => {
     const seen = new Set();
     const unique = [];
@@ -296,8 +337,8 @@ export const loadTagsForMemoryIds = (memoryIds) => {
     const uniqueIds = dedupeIds(memoryIds);
     if (uniqueIds.length === 0)
         return new Map();
-    const stmtSelectTags = prepareCached('SELECT memory_id, tag FROM tags WHERE memory_id IN (SELECT value FROM json_each(?)) ORDER BY memory_id, tag');
-    const rows = executeAll(stmtSelectTags, JSON.stringify(uniqueIds));
+    const stmt = prepareCached('SELECT memory_id, tag FROM tags WHERE memory_id IN (SELECT value FROM json_each(?)) ORDER BY memory_id, tag');
+    const rows = executeAll(stmt, JSON.stringify(uniqueIds));
     const tagsById = new Map();
     for (const row of rows) {
         const memoryId = toSafeInteger(row.memory_id, 'memory_id');
@@ -306,4 +347,3 @@ export const loadTagsForMemoryIds = (memoryIds) => {
     }
     return tagsById;
 };
-//# sourceMappingURL=db.js.map

package/dist/core/memory-read.d.ts

@@ -1,6 +1,5 @@
 import type { BatchDeleteResult, Memory, MemoryStats, StatementResult } from '../types.js';
 export declare const getMemory: (hash: string) => Memory | undefined;
 export declare const deleteMemory: (hash: string) => StatementResult;
-export declare const deleteMemories: (hashes: string[]) => BatchDeleteResult;
+export declare const deleteMemories: (hashes: string[], signal?: AbortSignal) => BatchDeleteResult;
 export declare const getStats: () => MemoryStats;
-//# sourceMappingURL=memory-read.d.ts.map

package/dist/core/memory-read.js

@@ -1,10 +1,22 @@
 import { executeGet, executeRun, loadTagsForMemoryIds, mapRowToMemory, prepareCached, toSafeInteger, withImmediateTransaction, } from './db.js';
+const throwIfAborted = (signal) => {
+    if (!signal)
+        return;
+    if (typeof signal.throwIfAborted === 'function') {
+        signal.throwIfAborted();
+        return;
+    }
+    if (signal.aborted) {
+        throw new Error('Operation aborted');
+    }
+};
+const loadMemoryRowByHashAndTouch = (hash) => {
+    const stmt = prepareCached('UPDATE memories SET accessed_at = CURRENT_TIMESTAMP WHERE hash = ? RETURNING *');
+    return executeGet(stmt, hash);
+};
 export const getMemory = (hash) => {
     return withImmediateTransaction(() => {
-        const stmtTouchMemoryByHash = prepareCached('UPDATE memories SET accessed_at = CURRENT_TIMESTAMP WHERE hash = ?');
-        executeRun(stmtTouchMemoryByHash, hash);
-        const stmtGetMemoryByHash = prepareCached('SELECT * FROM memories WHERE hash = ?');
-        const row = executeGet(stmtGetMemoryByHash, hash);
+        const row = loadMemoryRowByHashAndTouch(hash);
         if (!row)
             return undefined;
         const id = toSafeInteger(row.id, 'id');
@@ -13,32 +25,35 @@ export const getMemory = (hash) => {
     });
 };
 export const deleteMemory = (hash) => {
-    const stmtDeleteMemoryByHash = prepareCached('DELETE FROM memories WHERE hash = ?');
-    const result = executeRun(stmtDeleteMemoryByHash, hash);
+    const stmt = prepareCached('DELETE FROM memories WHERE hash = ?');
+    const result = executeRun(stmt, hash);
     return { changes: toSafeInteger(result.changes, 'changes') };
 };
 const deleteMemoryForBatch = (hash) => {
     try {
         const result = deleteMemory(hash);
         const deleted = result.changes > 0;
-        return deleted
-            ? { item: { hash, deleted: true }, succeeded: true }
-            : {
+        if (!deleted) {
+            return {
                 item: { hash, deleted: false, error: 'Memory not found' },
                 succeeded: false,
             };
+        }
+        return { item: { hash, deleted: true }, succeeded: true };
     }
     catch (err) {
         const message = err instanceof Error ? err.message : 'Unknown error';
         return { item: { hash, deleted: false, error: message }, succeeded: false };
     }
 };
-export const deleteMemories = (hashes) => {
-    const results = [];
-    let succeeded = 0;
-    let failed = 0;
+export const deleteMemories = (hashes, signal) => {
     return withImmediateTransaction(() => {
+        const results = [];
+        let succeeded = 0;
+        let failed = 0;
+        throwIfAborted(signal);
         for (const hash of hashes) {
+            throwIfAborted(signal);
             const outcome = deleteMemoryForBatch(hash);
             results.push(outcome.item);
             succeeded += outcome.succeeded ? 1 : 0;
@@ -78,4 +93,3 @@ export const getStats = () => {
         newestMemory: toDateString(dateRow?.newest),
     };
 };
-//# sourceMappingURL=memory-read.js.map

package/dist/core/memory-write.d.ts

@@ -10,11 +10,10 @@ export declare const createMemories: (items: {
     tags?: readonly string[];
     importance?: number;
     memory_type?: MemoryType;
-}[]) => BatchStoreResult;
+}[], signal?: AbortSignal) => BatchStoreResult;
 interface UpdateMemoryOptions {
     content: string;
     tags?: readonly string[] | undefined;
 }
 export declare const updateMemory: (hash: string, options: UpdateMemoryOptions) => MemoryUpdateResult;
 export {};
-//# sourceMappingURL=memory-write.d.ts.map

package/dist/core/memory-write.js

@@ -1,17 +1,25 @@
 import crypto from 'node:crypto';
-import { executeGet, executeRun, prepareCached, toSafeInteger, withImmediateTransaction, } from './db.js';
+import { executeGet, executeRun, findMemoryIdByHash, prepareCached, toSafeInteger, withImmediateTransaction, withSavepoint, } from './db.js';
 const MAX_TAGS = 100;
 const TAG_PATTERN = /^\S+$/;
+const throwIfAborted = (signal) => {
+    if (!signal)
+        return;
+    if (typeof signal.throwIfAborted === 'function') {
+        signal.throwIfAborted();
+        return;
+    }
+    if (signal.aborted) {
+        throw new Error('Operation aborted');
+    }
+};
 const validateTag = (tag) => {
-    if (tag.length === 0) {
+    if (tag.length === 0)
         throw new Error('Tag must be at least 1 character');
-    }
-    if (tag.length > 50) {
+    if (tag.length > 50)
         throw new Error('Tag exceeds 50 characters');
-    }
-    if (!TAG_PATTERN.test(tag)) {
+    if (!TAG_PATTERN.test(tag))
         throw new Error('Tag must not contain whitespace');
-    }
 };
 const validateTagCount = (tags, maxTags) => {
     if (tags.length > maxTags) {
@@ -32,38 +40,30 @@ const normalizeTags = (tags, maxTags) => {
     validateTagCount(tags, maxTags);
     return dedupeTags(tags);
 };
-const findMemoryIdByHash = (hash) => {
-    const stmtFindMemoryIdByHash = prepareCached('SELECT id FROM memories WHERE hash = ?');
-    const row = executeGet(stmtFindMemoryIdByHash, hash);
-    if (!row)
-        return undefined;
-    return toSafeInteger(row.id, 'id');
-};
 const insertTags = (memoryId, tags) => {
     if (tags.length === 0)
         return;
-    const stmtInsertTags = prepareCached('INSERT OR IGNORE INTO tags (memory_id, tag) SELECT ?, value FROM json_each(?)');
-    executeRun(stmtInsertTags, memoryId, JSON.stringify(tags));
+    const stmt = prepareCached('INSERT OR IGNORE INTO tags (memory_id, tag) SELECT ?, value FROM json_each(?)');
+    executeRun(stmt, memoryId, JSON.stringify(tags));
 };
-const buildHash = (content) => {
-    return crypto.createHash('sha256').update(content).digest('hex');
-};
-const requireMemoryId = (id) => {
-    if (id === undefined) {
-        throw new Error('Failed to resolve memory id');
-    }
-    return id;
+const replaceTags = (memoryId, tags) => {
+    const stmtDelete = prepareCached('DELETE FROM tags WHERE memory_id = ?');
+    executeRun(stmtDelete, memoryId);
+    insertTags(memoryId, normalizeTags(tags, MAX_TAGS));
 };
+const buildHash = (content) => crypto.createHash('sha256').update(content).digest('hex');
 const resolveMemoryId = (content, hash, importance, memoryType) => {
-    const stmtInsertMemory = prepareCached('INSERT OR IGNORE INTO memories (content, hash, importance, memory_type) VALUES (?, ?, ?, ?) RETURNING id');
-    const inserted = executeGet(stmtInsertMemory, content, hash, importance, memoryType);
+    const stmtInsert = prepareCached('INSERT OR IGNORE INTO memories (content, hash, importance, memory_type) VALUES (?, ?, ?, ?) RETURNING id');
+    const inserted = executeGet(stmtInsert, content, hash, importance, memoryType);
     if (inserted) {
         return { id: toSafeInteger(inserted.id, 'id'), isNew: true };
     }
-    const id = requireMemoryId(findMemoryIdByHash(hash));
-    return { id, isNew: false };
+    const existingId = findMemoryIdByHash(hash);
+    if (existingId === undefined) {
+        throw new Error('Failed to resolve memory id');
+    }
+    return { id: existingId, isNew: false };
 };
-export const createMemory = (input) => withImmediateTransaction(() => createMemoryInTransaction(input));
 const createMemoryInTransaction = (input) => {
     const { content, tags = [], importance = 0, memory_type: memoryType = 'general', } = input;
     const hash = buildHash(content);
@@ -72,62 +72,44 @@ const createMemoryInTransaction = (input) => {
     insertTags(id, normalizedTags);
     return { id, hash, isNew };
 };
-export const createMemories = (items) => {
-    return withImmediateTransaction(() => createMemoriesInTransaction(items));
-};
-const withSavepoint = (name, fn) => {
-    executeRun(prepareCached(`SAVEPOINT ${name}`));
+export const createMemory = (input) => withImmediateTransaction(() => createMemoryInTransaction(input));
+const createMemoryWithSavepoint = (index, item, signal) => {
+    const savepointName = `mem_item_${index}`;
     try {
-        const result = fn();
-        executeRun(prepareCached(`RELEASE ${name}`));
-        return result;
+        throwIfAborted(signal);
+        const created = withSavepoint(savepointName, () => createMemoryInTransaction(item));
+        return {
+            ok: true,
+            index,
+            hash: created.hash,
+            isNew: created.isNew,
+        };
     }
     catch (err) {
-        executeRun(prepareCached(`ROLLBACK TO ${name}`));
-        executeRun(prepareCached(`RELEASE ${name}`));
-        throw err;
+        const message = err instanceof Error ? err.message : 'Unknown error';
+        return { ok: false, index, error: message };
     }
 };
-const createMemoriesInTransaction = (items) => {
+const createMemoriesInTransaction = (items, signal) => {
     const results = [];
     let succeeded = 0;
     let failed = 0;
+    throwIfAborted(signal);
     for (let i = 0; i < items.length; i++) {
+        throwIfAborted(signal);
         const item = items[i];
         if (!item)
             continue;
-        const result = createMemoryWithSavepoint(i, item);
+        const result = createMemoryWithSavepoint(i, item, signal);
         results.push(result);
-        if (result.ok) {
+        if (result.ok)
             succeeded++;
-        }
-        else {
+        else
             failed++;
-        }
     }
     return { results, succeeded, failed };
 };
-const createMemoryWithSavepoint = (index, item) => {
-    const savepointName = `mem_item_${index}`;
-    try {
-        const created = withSavepoint(savepointName, () => createMemoryInTransaction(item));
-        return {
-            ok: true,
-            index,
-            hash: created.hash,
-            isNew: created.isNew,
-        };
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : 'Unknown error';
-        return { ok: false, index, error: message };
-    }
-};
-const replaceTags = (memoryId, tags) => {
-    const stmtDeleteTagsForMemory = prepareCached('DELETE FROM tags WHERE memory_id = ?');
-    executeRun(stmtDeleteTagsForMemory, memoryId);
-    insertTags(memoryId, normalizeTags(tags, MAX_TAGS));
-};
+export const createMemories = (items, signal) => withImmediateTransaction(() => createMemoriesInTransaction(items, signal));
 const assertNoDuplicateOnUpdate = (oldHash, newHash) => {
     if (newHash === oldHash)
         return;
@@ -136,22 +118,17 @@ const assertNoDuplicateOnUpdate = (oldHash, newHash) => {
         throw new Error('Content already exists as another memory');
     }
 };
-export const updateMemory = (hash, options) => {
+const updateMemoryInTransaction = (hash, options) => {
     const memoryId = findMemoryIdByHash(hash);
     if (memoryId === undefined)
         throw new Error('Memory not found');
-    return withImmediateTransaction(() => {
-        const newHash = buildHash(options.content);
-        // Check if new content would create a duplicate
-        assertNoDuplicateOnUpdate(hash, newHash);
-        // Update content and hash
-        const stmtUpdateContent = prepareCached('UPDATE memories SET content = ?, hash = ? WHERE id = ?');
-        executeRun(stmtUpdateContent, options.content, newHash, memoryId);
-        // Update tags if provided, otherwise preserve existing tags
-        if (options.tags !== undefined) {
-            replaceTags(memoryId, options.tags);
-        }
-        return { updated: true, oldHash: hash, newHash };
-    });
+    const newHash = buildHash(options.content);
+    assertNoDuplicateOnUpdate(hash, newHash);
+    const stmtUpdateContent = prepareCached('UPDATE memories SET content = ?, hash = ? WHERE id = ?');
+    executeRun(stmtUpdateContent, options.content, newHash, memoryId);
+    if (options.tags !== undefined) {
+        replaceTags(memoryId, options.tags);
+    }
+    return { updated: true, oldHash: hash, newHash };
 };
-//# sourceMappingURL=memory-write.js.map
+export const updateMemory = (hash, options) => withImmediateTransaction(() => updateMemoryInTransaction(hash, options));

package/dist/core/relationships.d.ts

@@ -13,4 +13,3 @@ export declare const deleteRelationship: (input: {
     to_hash: string;
     relation_type: string;
 }) => StatementResult;
-//# sourceMappingURL=relationships.d.ts.map

package/dist/core/relationships.js

@@ -1,21 +1,8 @@
-import { executeAll, executeGet, executeRun, mapRowToRelationship, prepareCached, toSafeInteger, withImmediateTransaction, } from './db.js';
-const findMemoryIdByHash = (hash) => {
-    const stmtFindMemoryIdByHash = prepareCached('SELECT id FROM memories WHERE hash = ?');
-    const row = executeGet(stmtFindMemoryIdByHash, hash);
-    if (!row)
-        return undefined;
-    return toSafeInteger(row.id, 'id');
-};
-const requireMemoryId = (hash) => {
-    const id = findMemoryIdByHash(hash);
-    if (id === undefined) {
-        throw new Error(`Memory not found: ${hash}`);
-    }
-    return id;
-};
+import { executeAll, executeGet, executeRun, mapRowToRelationship, prepareCached, requireMemoryIdByHash, toSafeInteger, withImmediateTransaction, } from './db.js';
+const buildNotFoundMessage = (hash) => `Memory not found: ${hash}`;
 export const createRelationship = (input) => withImmediateTransaction(() => {
-    const fromId = requireMemoryId(input.from_hash);
-    const toId = requireMemoryId(input.to_hash);
+    const fromId = requireMemoryIdByHash(input.from_hash, buildNotFoundMessage(input.from_hash));
+    const toId = requireMemoryIdByHash(input.to_hash, buildNotFoundMessage(input.to_hash));
     if (fromId === toId) {
         throw new Error('Cannot create self-referential relationship');
     }
@@ -28,7 +15,6 @@ export const createRelationship = (input) => withImmediateTransaction(() => {
     if (inserted) {
         return { id: toSafeInteger(inserted.id, 'id'), isNew: true };
     }
-    // Relationship already exists, find its ID
     const stmtFindRelationshipId = prepareCached(`
   SELECT id FROM relationships
   WHERE from_memory_id = ? AND to_memory_id = ? AND relation_type = ?
@@ -39,7 +25,6 @@ export const createRelationship = (input) => withImmediateTransaction(() => {
     }
     return { id: toSafeInteger(existing.id, 'id'), isNew: false };
 });
-// Query that joins with memories to get hashes instead of IDs
 const buildGetRelationshipsQuery = (direction) => {
     const baseSelect = `
     SELECT r.id, r.relation_type, r.created_at,
@@ -75,4 +60,3 @@ export const deleteRelationship = (input) => {
     const result = executeRun(stmtDeleteRelationship, input.from_hash, input.to_hash, input.relation_type);
     return { changes: toSafeInteger(result.changes, 'changes') };
 };
-//# sourceMappingURL=relationships.js.map

package/dist/core/search.d.ts

@@ -8,4 +8,3 @@ export declare const recallMemories: (input: {
     depth?: number;
 }, signal?: AbortSignal) => RecallResult;
 export {};
-//# sourceMappingURL=search.d.ts.map