@j0hanz/memdb 1.2.9 → 1.4.0

package/dist/core/memory-write.js

@@ -1,17 +1,18 @@
+import assert from 'node:assert/strict';
 import crypto from 'node:crypto';
-import { executeGet, executeRun, prepareCached, toSafeInteger, withImmediateTransaction, } from './db.js';
+import { throwIfAborted } from './abort.js';
+import { findMemoryIdByHash, sqlGet, sqlRun, toSafeInteger, withImmediateTransaction, withSavepoint, } from './db.js';
 const MAX_TAGS = 100;
 const TAG_PATTERN = /^\S+$/;
+const TAG_CASE_FOLD_LOCALE = 'en-US';
+const normalizeTagCase = (tag) => tag.normalize('NFKC').toLocaleLowerCase(TAG_CASE_FOLD_LOCALE);
 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) {
@@ -21,8 +22,9 @@ const validateTagCount = (tags, maxTags) => {
 const dedupeTags = (tags) => {
     const seen = new Set();
     for (const tag of tags) {
-        validateTag(tag);
-        seen.add(tag);
+        const normalized = normalizeTagCase(tag);
+        validateTag(normalized);
+        seen.add(normalized);
     }
     return [...seen];
 };
@@ -32,102 +34,85 @@ 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 buildHash = (content) => {
-    return crypto.createHash('sha256').update(content).digest('hex');
+    const insertResult = sqlRun `
+    INSERT OR IGNORE INTO tags (memory_id, tag)
+    SELECT ${memoryId}, value FROM json_each(${JSON.stringify(tags)})
+  `;
+    assert.ok(insertResult.changes >= 0, 'Invalid tag insert result');
 };
-const requireMemoryId = (id) => {
-    if (id === undefined) {
-        throw new Error('Failed to resolve memory id');
-    }
-    return id;
+const replaceTags = (memoryId, tags) => {
+    const deleteResult = sqlRun `DELETE FROM tags WHERE memory_id = ${memoryId}`;
+    assert.ok(deleteResult.changes >= 0, 'Invalid tag delete result');
+    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 inserted = sqlGet `
+    INSERT OR IGNORE INTO memories (content, hash, importance, memory_type)
+    VALUES (${content}, ${hash}, ${importance}, ${memoryType})
+    RETURNING id
+  `;
     if (inserted) {
         return { id: toSafeInteger(inserted.id, 'id'), isNew: true };
     }
-    const id = requireMemoryId(findMemoryIdByHash(hash));
-    return { id, isNew: false };
+    const existingId = findMemoryIdByHash(hash);
+    assert.ok(existingId !== undefined, 'Failed to resolve memory id');
+    return { id: existingId, isNew: false };
 };
-export const createMemory = (input) => withImmediateTransaction(() => createMemoryInTransaction(input));
-const createMemoryInTransaction = (input) => {
+const prepareMemory = (input) => {
     const { content, tags = [], importance = 0, memory_type: memoryType = 'general', } = input;
     const hash = buildHash(content);
     const normalizedTags = normalizeTags(tags, MAX_TAGS);
+    return { content, hash, normalizedTags, importance, memoryType };
+};
+const insertMemory = (input) => {
+    const { content, hash, normalizedTags, importance, memoryType } = input;
     const { id, isNew } = resolveMemoryId(content, hash, importance, memoryType);
     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(() => insertMemory(prepareMemory(input)));
+const createMemoryWithSavepoint = (index, item, signal) => {
+    const savepointName = `mem_item_${index}`;
     try {
-        const result = fn();
-        executeRun(prepareCached(`RELEASE ${name}`));
-        return result;
+        throwIfAborted(signal);
+        const prepared = prepareMemory(item);
+        const created = withSavepoint(savepointName, () => insertMemory(prepared));
+        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 +121,21 @@ 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 updateResult = sqlRun `
+    UPDATE memories
+    SET content = ${options.content}, hash = ${newHash}
+    WHERE id = ${memoryId}
+  `;
+    assert.ok(updateResult.changes >= 0, 'Invalid update result');
+    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,78 +1,75 @@
-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 { mapRowToRelationship, requireMemoryIdByHash, sqlAll, sqlGet, sqlRun, 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');
     }
-    const stmtInsertRelationship = prepareCached(`
-  INSERT OR IGNORE INTO relationships (from_memory_id, to_memory_id, relation_type)
-  VALUES (?, ?, ?)
-  RETURNING id
-`);
-    const inserted = executeGet(stmtInsertRelationship, fromId, toId, input.relation_type);
+    const inserted = sqlGet `
+      INSERT OR IGNORE INTO relationships
+        (from_memory_id, to_memory_id, relation_type)
+      VALUES (${fromId}, ${toId}, ${input.relation_type})
+      RETURNING id
+    `;
     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 = ?
-`);
-    const existing = executeGet(stmtFindRelationshipId, fromId, toId, input.relation_type);
+    const existing = sqlGet `
+      SELECT id FROM relationships
+      WHERE from_memory_id = ${fromId}
+        AND to_memory_id = ${toId}
+        AND relation_type = ${input.relation_type}
+    `;
     if (!existing) {
         throw new Error('Failed to resolve relationship id');
     }
     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,
-           mf.hash as from_hash, mt.hash as to_hash
-    FROM relationships r
-    JOIN memories mf ON r.from_memory_id = mf.id
-    JOIN memories mt ON r.to_memory_id = mt.id
-  `;
-    const orderBy = ' ORDER BY r.relation_type, mf.hash, mt.hash, r.created_at, r.id';
-    switch (direction) {
-        case 'outgoing':
-            return `${baseSelect} WHERE mf.hash = ?${orderBy}`;
-        case 'incoming':
-            return `${baseSelect} WHERE mt.hash = ?${orderBy}`;
-        case 'both':
-            return `${baseSelect} WHERE mf.hash = ? OR mt.hash = ?${orderBy}`;
-    }
-};
 export const getRelationships = (input) => {
     const direction = input.direction ?? 'both';
-    const stmt = prepareCached(buildGetRelationshipsQuery(direction));
-    const params = direction === 'both' ? [input.hash, input.hash] : [input.hash];
-    const rows = executeAll(stmt, ...params);
+    const rows = (() => {
+        switch (direction) {
+            case 'outgoing':
+                return sqlAll `
+          SELECT r.id, r.relation_type, r.created_at,
+                 mf.hash as from_hash, mt.hash as to_hash
+          FROM relationships r
+          JOIN memories mf ON r.from_memory_id = mf.id
+          JOIN memories mt ON r.to_memory_id = mt.id
+          WHERE mf.hash = ${input.hash}
+          ORDER BY r.relation_type, mf.hash, mt.hash, r.created_at, r.id
+        `;
+            case 'incoming':
+                return sqlAll `
+          SELECT r.id, r.relation_type, r.created_at,
+                 mf.hash as from_hash, mt.hash as to_hash
+          FROM relationships r
+          JOIN memories mf ON r.from_memory_id = mf.id
+          JOIN memories mt ON r.to_memory_id = mt.id
+          WHERE mt.hash = ${input.hash}
+          ORDER BY r.relation_type, mf.hash, mt.hash, r.created_at, r.id
+        `;
+            case 'both':
+                return sqlAll `
+          SELECT r.id, r.relation_type, r.created_at,
+                 mf.hash as from_hash, mt.hash as to_hash
+          FROM relationships r
+          JOIN memories mf ON r.from_memory_id = mf.id
+          JOIN memories mt ON r.to_memory_id = mt.id
+          WHERE mf.hash = ${input.hash} OR mt.hash = ${input.hash}
+          ORDER BY r.relation_type, mf.hash, mt.hash, r.created_at, r.id
+        `;
+        }
+    })();
     return rows.map(mapRowToRelationship);
 };
 export const deleteRelationship = (input) => {
-    const stmtDeleteRelationship = prepareCached(`
-  DELETE FROM relationships
-  WHERE from_memory_id = (SELECT id FROM memories WHERE hash = ?)
-    AND to_memory_id = (SELECT id FROM memories WHERE hash = ?)
-    AND relation_type = ?
-`);
-    const result = executeRun(stmtDeleteRelationship, input.from_hash, input.to_hash, input.relation_type);
+    const result = sqlRun `
+    DELETE FROM relationships
+    WHERE from_memory_id = (SELECT id FROM memories WHERE hash = ${input.from_hash})
+      AND to_memory_id = (SELECT id FROM memories WHERE hash = ${input.to_hash})
+      AND relation_type = ${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