ocean-brain 0.8.2 → 0.11.0

package/server/dist/features/note/services/authoring.js

@@ -1,7 +1,7 @@
 import models from "../../../models.js";
 import { extractTagIdsFromContentJson, markdownToBlocksJson } from "../../../modules/blocknote.js";
+import { replaceNoteReferences } from "./note-reference-index.js";
 import { buildNoteSearchProjection } from "./search.js";
-import { captureNoteBaseline } from "./snapshot.js";
 class InvalidNoteAuthoringInputError extends Error {
   constructor(message) {
     super(message);
@@ -60,59 +60,28 @@ const createNoteAuthoringService = (deps) => {
         ...input.layout ? { layout: input.layout } : {}
       });
       return serializeNote(note);
-    },
-    updateNote: async (input) => {
-      if (input.title === void 0 && input.markdown === void 0 && input.layout === void 0) {
-        throw new InvalidNoteAuthoringInputError("At least one note field must be provided for update.");
-      }
-      const existingNote = await deps.findNoteById(input.id);
-      if (!existingNote) {
-        return null;
-      }
-      const nextData = {};
-      if (input.title !== void 0) {
-        const title = input.title.trim();
-        if (!title) {
-          throw new InvalidNoteAuthoringInputError("A note title is required.");
-        }
-        nextData.title = await replacePlaceholders(title);
-      }
-      if (input.markdown !== void 0) {
-        const replacedMarkdown = await replacePlaceholders(input.markdown);
-        nextData.content = await deps.parseMarkdownToContentJson(replacedMarkdown);
-        nextData.tagIds = deps.extractTagIds(nextData.content);
-      }
-      if (input.layout !== void 0) {
-        nextData.layout = input.layout;
-      }
-      await deps.captureBaseline({
-        noteId: input.id,
-        ...input.editSessionId ? { editSessionId: input.editSessionId } : {},
-        ...input.snapshotMeta ? { meta: input.snapshotMeta } : {}
-      });
-      const updatedNote = await deps.updateNote(input.id, nextData);
-      return serializeNote(updatedNote);
     }
   };
 };
 const defaultNoteAuthoringService = createNoteAuthoringService({
   createNote: async (input) => {
-    return models.note.create({
-      data: {
-        title: input.title,
-        content: input.content,
-        ...buildNoteSearchProjection({
+    return models.$transaction(async (tx) => {
+      const note = await tx.note.create({
+        data: {
           title: input.title,
-          content: input.content
-        }),
-        ...input.layout ? { layout: input.layout } : {},
-        ...input.tagIds ? { tags: { connect: input.tagIds.map((id) => ({ id: Number(id) })) } } : {}
-      }
+          content: input.content,
+          ...buildNoteSearchProjection({
+            title: input.title,
+            content: input.content
+          }),
+          ...input.layout ? { layout: input.layout } : {},
+          ...input.tagIds ? { tags: { connect: input.tagIds.map((id) => ({ id: Number(id) })) } } : {}
+        }
+      });
+      await replaceNoteReferences(tx, note.id, input.content);
+      return note;
     });
   },
-  findNoteById: async (id) => {
-    return models.note.findUnique({ where: { id } });
-  },
   findPlaceholders: async (templates) => {
     if (templates.length === 0) {
       return [];
@@ -126,45 +95,13 @@ const defaultNoteAuthoringService = createNoteAuthoringService({
     });
   },
   parseMarkdownToContentJson: markdownToBlocksJson,
-  extractTagIds: extractTagIdsFromContentJson,
-  captureBaseline: captureNoteBaseline,
-  updateNote: async (id, input) => {
-    const existingNote = await models.note.findUnique({
-      where: { id },
-      select: {
-        title: true,
-        content: true
-      }
-    });
-    if (!existingNote) {
-      throw new Error("NOTE_NOT_FOUND");
-    }
-    const nextTitle = input.title ?? existingNote.title;
-    const nextContent = input.content ?? existingNote.content;
-    return models.note.update({
-      where: { id },
-      data: {
-        title: input.title,
-        content: input.content,
-        layout: input.layout,
-        ...buildNoteSearchProjection({
-          title: nextTitle,
-          content: nextContent
-        }),
-        ...input.tagIds ? { tags: { set: input.tagIds.map((tagId) => ({ id: Number(tagId) })) } } : {}
-      }
-    });
-  }
+  extractTagIds: extractTagIdsFromContentJson
 });
 const createNoteFromMarkdown = async (input) => {
   return defaultNoteAuthoringService.createNote(input);
 };
-const updateNoteFromMarkdown = async (input) => {
-  return defaultNoteAuthoringService.updateNote(input);
-};
 export {
   InvalidNoteAuthoringInputError,
   createNoteAuthoringService,
-  createNoteFromMarkdown,
-  updateNoteFromMarkdown
+  createNoteFromMarkdown
 };

package/server/dist/features/note/services/markdown-patch.js

@@ -21,6 +21,66 @@ const getLineRange = (markdown, match) => {
     lineEnd
   };
 };
+const MARKDOWN_PATCH_WHITESPACE_PATTERN = /\p{Zs}| |&#(?:x[0-9a-f]+|\d+);/giu;
+const SPACE_SEPARATOR_PATTERN = /^\p{Zs}$/u;
+const normalizePatchWhitespaceToken = (value) => {
+  if (!value.startsWith("&")) {
+    return " ";
+  }
+  if (/^ $/i.test(value)) {
+    return " ";
+  }
+  const numericValue = value.slice(2, -1);
+  const isHexadecimal = numericValue.toLowerCase().startsWith("x");
+  const codePoint = Number.parseInt(isHexadecimal ? numericValue.slice(1) : numericValue, isHexadecimal ? 16 : 10);
+  if (!Number.isSafeInteger(codePoint) || codePoint < 0 || codePoint > 1114111) {
+    return value;
+  }
+  return SPACE_SEPARATOR_PATTERN.test(String.fromCodePoint(codePoint)) ? " " : value;
+};
+const normalizeMarkdownPatchText = (value) => {
+  let text = "";
+  const rawStarts = [];
+  const rawEnds = [];
+  const appendText = (appendValue, rawStart, rawEnd) => {
+    text += appendValue;
+    for (let index = 0; index < appendValue.length; index += 1) {
+      rawStarts.push(rawStart);
+      rawEnds.push(rawEnd);
+    }
+  };
+  const appendRawRange = (start, end) => {
+    for (let index = start; index < end; ) {
+      const codePoint = value.codePointAt(index);
+      if (codePoint === void 0) {
+        break;
+      }
+      const character = String.fromCodePoint(codePoint);
+      appendText(character, index, index + character.length);
+      index += character.length;
+    }
+  };
+  let sourceCursor = 0;
+  for (const match of value.matchAll(MARKDOWN_PATCH_WHITESPACE_PATTERN)) {
+    const start = match.index;
+    const token = match[0];
+    const end = start + token.length;
+    appendRawRange(sourceCursor, start);
+    const normalizedToken = normalizePatchWhitespaceToken(token);
+    if (normalizedToken === token) {
+      appendRawRange(start, end);
+    } else {
+      appendText(normalizedToken, start, end);
+    }
+    sourceCursor = end;
+  }
+  appendRawRange(sourceCursor, value.length);
+  return {
+    text,
+    rawStarts,
+    rawEnds
+  };
+};
 const buildExcerpt = (markdown, start, end) => {
   const excerpt = markdown.slice(start, end).trim();
   return excerpt.length > 0 ? excerpt : void 0;
@@ -46,19 +106,27 @@ const toPatchMatch = (markdown, match, totalMatches) => {
 };
 const findExactTextMatches = (markdown, text) => {
   const matches = [];
+  const normalizedMarkdown = normalizeMarkdownPatchText(markdown);
+  const normalizedText = normalizeMarkdownPatchText(text).text;
   let searchStart = 0;
-  while (searchStart <= markdown.length) {
-    const start = markdown.indexOf(text, searchStart);
+  while (searchStart <= normalizedMarkdown.text.length) {
+    const start = normalizedMarkdown.text.indexOf(normalizedText, searchStart);
     if (start === -1) {
       break;
     }
+    const end = start + normalizedText.length;
+    const rawStart = normalizedMarkdown.rawStarts[start];
+    const rawEnd = normalizedMarkdown.rawEnds[end - 1];
+    if (rawStart === void 0 || rawEnd === void 0) {
+      break;
+    }
     matches.push({
       matchIndex: matches.length,
-      start,
-      end: start + text.length,
-      text
+      start: rawStart,
+      end: rawEnd,
+      text: markdown.slice(rawStart, rawEnd)
     });
-    searchStart = start + text.length;
+    searchStart = end;
   }
   return matches;
 };
@@ -238,10 +306,14 @@ const createChangePlan = ({
   };
 };
 const matchHasAnchors = (markdown, match, selector) => {
-  if (selector.before !== void 0 && !markdown.slice(0, match.start).endsWith(selector.before)) {
+  if (selector.before !== void 0 && !normalizeMarkdownPatchText(markdown.slice(0, match.start)).text.endsWith(
+    normalizeMarkdownPatchText(selector.before).text
+  )) {
     return false;
   }
-  if (selector.after !== void 0 && !markdown.slice(match.end).startsWith(selector.after)) {
+  if (selector.after !== void 0 && !normalizeMarkdownPatchText(markdown.slice(match.end)).text.startsWith(
+    normalizeMarkdownPatchText(selector.after).text
+  )) {
     return false;
   }
   return true;

package/server/dist/features/note/services/note-reference-index.js

@@ -0,0 +1,98 @@
+import models from "../../../models.js";
+import { extractReferenceBlocksFromContent, normalizeReferenceId } from "./content-blocks.js";
+const NOTE_REFERENCE_INDEX_VERSION = 1;
+const NOTE_REFERENCE_INDEX_STATE_ID = 1;
+const SQLITE_MAX_INT_ID = 2147483647;
+const REFERENCE_INDEX_REBUILD_BATCH_SIZE = 250;
+const toNoteId = (value) => {
+  const normalized = normalizeReferenceId(value);
+  if (!normalized || !/^[1-9]\d*$/.test(normalized)) {
+    return null;
+  }
+  const id = Number(normalized);
+  return Number.isSafeInteger(id) && id <= SQLITE_MAX_INT_ID ? id : null;
+};
+const extractNoteReferenceIds = (content) => {
+  return Array.from(
+    new Set(
+      extractReferenceBlocksFromContent(content).map((block) => toNoteId(block.props?.id)).filter((id) => id !== null)
+    )
+  );
+};
+const replaceNoteReferences = async (db, sourceNoteId, content) => {
+  const targetIds = extractNoteReferenceIds(content).filter((targetNoteId) => targetNoteId !== sourceNoteId);
+  await db.noteReference.deleteMany({ where: { sourceNoteId } });
+  if (targetIds.length === 0) {
+    return 0;
+  }
+  const references = targetIds.map((targetNoteId) => ({ sourceNoteId, targetNoteId }));
+  if (references.length > 0) {
+    await db.noteReference.createMany({ data: references });
+  }
+  return references.length;
+};
+const rebuildNoteReferenceIndex = async () => {
+  await models.noteReference.deleteMany();
+  let cursor = 0;
+  let processedCount = 0;
+  while (true) {
+    const notes = await models.note.findMany({
+      where: { id: { gt: cursor } },
+      orderBy: { id: "asc" },
+      take: REFERENCE_INDEX_REBUILD_BATCH_SIZE,
+      select: {
+        id: true,
+        content: true
+      }
+    });
+    if (notes.length === 0) {
+      break;
+    }
+    const references = notes.flatMap(
+      (note) => extractNoteReferenceIds(note.content).filter((targetNoteId) => targetNoteId !== note.id).map((targetNoteId) => ({
+        sourceNoteId: note.id,
+        targetNoteId
+      }))
+    );
+    if (references.length > 0) {
+      await models.noteReference.createMany({ data: references });
+      processedCount += references.length;
+    }
+    cursor = notes[notes.length - 1].id;
+  }
+  await models.noteReferenceIndexState.upsert({
+    where: { id: NOTE_REFERENCE_INDEX_STATE_ID },
+    create: {
+      id: NOTE_REFERENCE_INDEX_STATE_ID,
+      version: NOTE_REFERENCE_INDEX_VERSION,
+      updatedAt: /* @__PURE__ */ new Date()
+    },
+    update: {
+      version: NOTE_REFERENCE_INDEX_VERSION
+    }
+  });
+  return processedCount;
+};
+let activeRebuild = null;
+const ensureNoteReferenceIndex = async () => {
+  const state = await models.noteReferenceIndexState.findUnique({
+    where: { id: NOTE_REFERENCE_INDEX_STATE_ID },
+    select: { version: true }
+  });
+  if (state?.version === NOTE_REFERENCE_INDEX_VERSION) {
+    return 0;
+  }
+  if (!activeRebuild) {
+    activeRebuild = rebuildNoteReferenceIndex().finally(() => {
+      activeRebuild = null;
+    });
+  }
+  return activeRebuild;
+};
+export {
+  NOTE_REFERENCE_INDEX_STATE_ID,
+  NOTE_REFERENCE_INDEX_VERSION,
+  ensureNoteReferenceIndex,
+  extractNoteReferenceIds,
+  replaceNoteReferences
+};

package/server/dist/features/note/services/properties.js

@@ -329,6 +329,13 @@ const findReferencedRemovedPropertyOptionValue = ({
   }
   return null;
 };
+const viewQueryReferencesProperty = ({ query, key }) => {
+  const parsed = parseViewQueryRecord(query);
+  if (!parsed || !Array.isArray(parsed.propertyFilters)) {
+    return false;
+  }
+  return parsed.propertyFilters.some((filter) => isRecord(filter) && getNormalizedViewFilterKey(filter) === key);
+};
 const buildTypedValueData = async (input, definitionId, tx = models) => {
   const resetValues = {
     textValue: null,
@@ -695,6 +702,18 @@ const deleteNotePropertyDefinition = async ({
     if (!definition) {
       return null;
     }
+    const referencingViewSections = await tx.viewSection.findMany({
+      where: { query: { contains: definition.key } },
+      select: { title: true, query: true }
+    });
+    const referencingView = referencingViewSections.find(
+      (section) => viewQueryReferencesProperty({ query: section.query, key: definition.key })
+    );
+    if (referencingView) {
+      throw new InvalidNotePropertyInputError(
+        `Property ${definition.key} is used by view ${referencingView.title} and cannot be deleted.`
+      );
+    }
     const affectedNoteCount = definition._count.properties;
     if (affectedNoteCount > 0 && !confirmImpact) {
       throw new NotePropertyDeleteConfirmationRequiredError(normalizedKey, affectedNoteCount);
@@ -869,5 +888,6 @@ export {
   updateNotePropertiesWithVersionGuard,
   updateNotePropertiesWithVersionGuardAndSnapshot,
   updateNotePropertyDefinition,
-  validateNotePropertiesPatchValues
+  validateNotePropertiesPatchValues,
+  viewQueryReferencesProperty
 };

package/server/dist/features/note/services/property-restore.js

@@ -0,0 +1,26 @@
+const resolveRestoredPropertyTarget = async (property, deps) => {
+  const definition = await deps.findDefinitionByKey(property.key);
+  if (!definition || definition.valueType !== property.valueType) {
+    return null;
+  }
+  if (property.valueType !== "select") {
+    return {
+      propertyDefinitionId: definition.id,
+      optionId: null
+    };
+  }
+  if (!property.optionValue) {
+    return null;
+  }
+  const option = await deps.findOptionByValue(definition.id, property.optionValue);
+  if (!option) {
+    return null;
+  }
+  return {
+    propertyDefinitionId: definition.id,
+    optionId: option.id
+  };
+};
+export {
+  resolveRestoredPropertyTarget
+};

package/server/dist/features/note/services/search.js

@@ -140,6 +140,10 @@ const extractVisibleSearchTextFromContent = (content) => {
     return "";
   }
 };
+const NOTE_CONTENT_PREVIEW_MAX_LENGTH = 100;
+const buildNoteContentPreview = (content) => {
+  return extractVisibleSearchTextFromContent(content).slice(0, NOTE_CONTENT_PREVIEW_MAX_LENGTH);
+};
 const matchesNoteSearchQuery = (note, query) => {
   const parsedQuery = typeof query === "string" ? parseNoteSearchQuery(query) : query;
   if (!parsedQuery.hasFilters) {
@@ -166,6 +170,7 @@ export {
   NOTE_SEARCH_IGNORED_NODE_TYPES,
   NOTE_SEARCH_PASS_THROUGH_NODE_TYPES,
   NOTE_SEARCH_TEXT_SCHEMA_VERSION,
+  buildNoteContentPreview,
   buildNoteSearchProjection,
   buildNoteSearchText,
   extractVisibleSearchTextFromContent,

package/server/dist/features/note/services/snapshot.js

@@ -1,6 +1,6 @@
 import { FILE_HEADERS_ONLY, formatPatch, structuredPatch } from "diff";
 import { ensureTagByName } from "../../../features/tag/services/organization.js";
-import models from "../../../models.js";
+import models, { Prisma } from "../../../models.js";
 import { blocksToMarkdown, extractTagIdsFromContentJson } from "../../../modules/blocknote.js";
 import { parseBlockNoteContent, walkBlockNoteTree } from "../../../modules/blocknote-tree.js";
 import {
@@ -10,7 +10,10 @@ import {
   SNAPSHOT_RETENTION_DAYS
 } from "../../../modules/recovery-retention.js";
 import { calculateMarkdownSha256 } from "./markdown-patch.js";
+import { replaceNoteReferences } from "./note-reference-index.js";
+import { resolveRestoredPropertyTarget } from "./property-restore.js";
 import { buildNoteSearchProjection, extractVisibleSearchTextFromContent } from "./search.js";
+import { createNoteVersionConflictError, MissingNoteVersionError, parseNoteVersion } from "./write-conflict.js";
 const SNAPSHOT_CONTENT_PREVIEW_MAX_LENGTH = 240;
 const parseMeta = (value) => {
   if (!value) {
@@ -384,6 +387,19 @@ const createNoteSnapshotService = (deps) => ({
     if (!note) {
       return null;
     }
+    if (!note.updatedAt) {
+      throw new Error("Note update time is required to restore a snapshot.");
+    }
+    const expectedTimestamp = parseNoteVersion(options.expectedUpdatedAt);
+    if (expectedTimestamp === null) {
+      throw new MissingNoteVersionError();
+    }
+    if (note.updatedAt.getTime() !== expectedTimestamp) {
+      throw createNoteVersionConflictError({
+        expectedUpdatedAt: expectedTimestamp,
+        currentUpdatedAt: note.updatedAt.getTime()
+      });
+    }
     const payload = parsePayload(snapshot.payload);
     const resolvedTags = deps.resolveRestoredTags ? await deps.resolveRestoredTags(payload.content) : extractRestoredTagIds(payload.content);
     const restoredPayload = resolvedTags && !Array.isArray(resolvedTags) ? {
@@ -403,7 +419,8 @@ const createNoteSnapshotService = (deps) => ({
     }
     const restoredNote = await deps.updateNote(snapshot.noteId, {
       ...restoredPayload,
-      ...restoredTagIds !== void 0 ? { tagIds: restoredTagIds } : {}
+      ...restoredTagIds !== void 0 ? { tagIds: restoredTagIds } : {},
+      expectedUpdatedAt: options.expectedUpdatedAt
     });
     await deps.trimOverflowSnapshots(note.id, SNAPSHOT_MAX_PER_NOTE, RECOVERY_CLEANUP_BATCH_LIMIT);
     return restoredNote;
@@ -527,68 +544,75 @@ const defaultNoteSnapshotService = createNoteSnapshotService({
     });
   },
   updateNote: async (id, input) => {
-    const { tagIds, properties, ...noteInput } = input;
-    return models.$transaction(async (tx) => {
-      const note = await tx.note.update({
-        where: { id },
-        data: {
-          ...noteInput,
-          ...buildNoteSearchProjection({
-            title: noteInput.title,
-            content: noteInput.content
-          }),
-          ...tagIds !== void 0 ? { tags: { set: tagIds.map((tagId) => ({ id: tagId })) } } : {}
+    const { tagIds, properties, expectedUpdatedAt, ...noteInput } = input;
+    const expectedTimestamp = parseNoteVersion(expectedUpdatedAt);
+    if (expectedTimestamp === null) {
+      throw new MissingNoteVersionError();
+    }
+    try {
+      return await models.$transaction(async (tx) => {
+        const note = await tx.note.update({
+          where: { id, updatedAt: new Date(expectedTimestamp) },
+          data: {
+            ...noteInput,
+            ...buildNoteSearchProjection({
+              title: noteInput.title,
+              content: noteInput.content
+            }),
+            ...tagIds !== void 0 ? { tags: { set: tagIds.map((tagId) => ({ id: tagId })) } } : {}
+          }
+        });
+        if (noteInput.content !== void 0) {
+          await replaceNoteReferences(tx, note.id, noteInput.content);
         }
-      });
-      if (properties !== void 0) {
-        await tx.noteProperty.deleteMany({ where: { noteId: id } });
-        for (const property of properties) {
-          const definition = await tx.propertyDefinition.upsert({
-            where: { key: property.key },
-            create: {
-              key: property.key,
-              name: property.name,
-              valueType: property.valueType
-            },
-            update: {
-              name: property.name,
-              valueType: property.valueType
+        if (properties !== void 0) {
+          await tx.noteProperty.deleteMany({ where: { noteId: id } });
+          for (const property of properties) {
+            const target = await resolveRestoredPropertyTarget(property, {
+              findDefinitionByKey: (key) => tx.propertyDefinition.findUnique({ where: { key } }),
+              findOptionByValue: (propertyDefinitionId, value) => tx.propertyOption.findUnique({
+                where: {
+                  propertyDefinitionId_value: {
+                    propertyDefinitionId,
+                    value
+                  }
+                }
+              })
+            });
+            if (!target) {
+              continue;
             }
-          });
-          const option = property.valueType === "select" && property.optionValue ? await tx.propertyOption.upsert({
-            where: {
-              propertyDefinitionId_value: {
-                propertyDefinitionId: definition.id,
-                value: property.optionValue
+            await tx.noteProperty.create({
+              data: {
+                noteId: id,
+                propertyDefinitionId: target.propertyDefinitionId,
+                optionId: target.optionId,
+                textValue: property.textValue ?? null,
+                textValueNormalized: property.textValueNormalized ?? null,
+                numberValue: property.numberValue ?? null,
+                dateValue: property.dateValue ? new Date(property.dateValue) : null,
+                boolValue: property.boolValue ?? null
               }
-            },
-            create: {
-              propertyDefinitionId: definition.id,
-              value: property.optionValue,
-              label: property.optionLabel ?? property.optionValue,
-              color: property.optionColor ?? null
-            },
-            update: {
-              label: property.optionLabel ?? property.optionValue,
-              color: property.optionColor ?? null
-            }
-          }) : null;
-          await tx.noteProperty.create({
-            data: {
-              noteId: id,
-              propertyDefinitionId: definition.id,
-              optionId: option?.id ?? null,
-              textValue: property.textValue ?? null,
-              textValueNormalized: property.textValueNormalized ?? null,
-              numberValue: property.numberValue ?? null,
-              dateValue: property.dateValue ? new Date(property.dateValue) : null,
-              boolValue: property.boolValue ?? null
-            }
+            });
+          }
+        }
+        return note;
+      });
+    } catch (error) {
+      if (error instanceof Prisma.PrismaClientKnownRequestError && error.code === "P2025") {
+        const currentNote = await models.note.findUnique({
+          where: { id },
+          select: { updatedAt: true }
+        });
+        if (currentNote && currentNote.updatedAt.getTime() !== expectedTimestamp) {
+          throw createNoteVersionConflictError({
+            expectedUpdatedAt: expectedTimestamp,
+            currentUpdatedAt: currentNote.updatedAt.getTime()
           });
         }
       }
-      return note;
-    });
+      throw error;
+    }
   }
 });
 const captureNoteBaseline = async (input) => {