feat: item linking (#1779)

2022-10-11 23:54:00 +05:30
parent d22c164e5d
commit e3f28421ff
68 changed files with 2064 additions and 1277 deletions
--- a/packages/snjs/lib/Services/Items/ItemManager.spec.ts
+++ b/packages/snjs/lib/Services/Items/ItemManager.spec.ts
@@ -405,41 +405,6 @@ describe('itemManager', () => {
      const notes = itemManager.getDisplayableNotes()
      expect(notes).toHaveLength(1)
    })
-
-    it('adding a note to a tag hierarchy should add the note to its parent too', async () => {
-      itemManager = createService()
-      const parentTag = createTag('parent')
-      const childTag = createTag('child')
-      const note = createNote('note')
-
-      await itemManager.insertItems([parentTag, childTag, note])
-      await itemManager.setTagParent(parentTag, childTag)
-
-      await itemManager.addTagToNote(note, childTag, true)
-
-      const tags = itemManager.getSortedTagsForNote(note)
-
-      expect(tags).toHaveLength(2)
-      expect(tags[0].uuid).toEqual(childTag.uuid)
-      expect(tags[1].uuid).toEqual(parentTag.uuid)
-    })
-
-    it('adding a note to a tag hierarchy should not add the note to its parent if hierarchy option is disabled', async () => {
-      itemManager = createService()
-      const parentTag = createTag('parent')
-      const childTag = createTag('child')
-      const note = createNote('note')
-
-      await itemManager.insertItems([parentTag, childTag, note])
-      await itemManager.setTagParent(parentTag, childTag)
-
-      await itemManager.addTagToNote(note, childTag, false)
-
-      const tags = itemManager.getSortedTagsForNote(note)
-
-      expect(tags).toHaveLength(1)
-      expect(tags[0].uuid).toEqual(childTag.uuid)
-    })
  })

  describe('template items', () => {
@@ -703,47 +668,6 @@ describe('itemManager', () => {
  })

  describe('files', () => {
-    it('associates with note', async () => {
-      itemManager = createService()
-      const note = createNote('invoices')
-      const file = createFile('invoice_1.pdf')
-      await itemManager.insertItems([note, file])
-
-      const resultingFile = await itemManager.associateFileWithNote(file, note)
-      const references = resultingFile.references
-
-      expect(references).toHaveLength(1)
-      expect(references[0].uuid).toEqual(note.uuid)
-    })
-
-    it('disassociates with note', async () => {
-      itemManager = createService()
-      const note = createNote('invoices')
-      const file = createFile('invoice_1.pdf')
-      await itemManager.insertItems([note, file])
-
-      const associatedFile = await itemManager.associateFileWithNote(file, note)
-      const disassociatedFile = await itemManager.disassociateFileWithNote(associatedFile, note)
-      const references = disassociatedFile.references
-
-      expect(references).toHaveLength(0)
-    })
-
-    it('should get files associated with note', async () => {
-      itemManager = createService()
-      const note = createNote('invoices')
-      const file = createFile('invoice_1.pdf')
-      const secondFile = createFile('unrelated-file.xlsx')
-      await itemManager.insertItems([note, file, secondFile])
-
-      await itemManager.associateFileWithNote(file, note)
-
-      const filesAssociatedWithNote = itemManager.getFilesForNote(note)
-
-      expect(filesAssociatedWithNote).toHaveLength(1)
-      expect(filesAssociatedWithNote[0].uuid).toBe(file.uuid)
-    })
-
    it('should correctly rename file to filename that has extension', async () => {
      itemManager = createService()
      const file = createFile('initialName.ext')
@@ -774,4 +698,231 @@ describe('itemManager', () => {
      expect(renamedFile.name).toBe('anotherName')
    })
  })
+
+  describe('linking', () => {
+    it('adding a note to a tag hierarchy should add the note to its parent too', async () => {
+      itemManager = createService()
+      const parentTag = createTag('parent')
+      const childTag = createTag('child')
+      const note = createNote('note')
+
+      await itemManager.insertItems([parentTag, childTag, note])
+      await itemManager.setTagParent(parentTag, childTag)
+
+      await itemManager.addTagToNote(note, childTag, true)
+
+      const tags = itemManager.getSortedTagsForItem(note)
+
+      expect(tags).toHaveLength(2)
+      expect(tags[0].uuid).toEqual(childTag.uuid)
+      expect(tags[1].uuid).toEqual(parentTag.uuid)
+    })
+
+    it('adding a note to a tag hierarchy should not add the note to its parent if hierarchy option is disabled', async () => {
+      itemManager = createService()
+      const parentTag = createTag('parent')
+      const childTag = createTag('child')
+      const note = createNote('note')
+
+      await itemManager.insertItems([parentTag, childTag, note])
+      await itemManager.setTagParent(parentTag, childTag)
+
+      await itemManager.addTagToNote(note, childTag, false)
+
+      const tags = itemManager.getSortedTagsForItem(note)
+
+      expect(tags).toHaveLength(1)
+      expect(tags[0].uuid).toEqual(childTag.uuid)
+    })
+
+    it('adding a file to a tag hierarchy should add the file to its parent too', async () => {
+      itemManager = createService()
+      const parentTag = createTag('parent')
+      const childTag = createTag('child')
+      const file = createFile('file')
+
+      await itemManager.insertItems([parentTag, childTag, file])
+      await itemManager.setTagParent(parentTag, childTag)
+
+      await itemManager.addTagToFile(file, childTag, true)
+
+      const tags = itemManager.getSortedTagsForItem(file)
+
+      expect(tags).toHaveLength(2)
+      expect(tags[0].uuid).toEqual(childTag.uuid)
+      expect(tags[1].uuid).toEqual(parentTag.uuid)
+    })
+
+    it('adding a file to a tag hierarchy should not add the file to its parent if hierarchy option is disabled', async () => {
+      itemManager = createService()
+      const parentTag = createTag('parent')
+      const childTag = createTag('child')
+      const file = createFile('file')
+
+      await itemManager.insertItems([parentTag, childTag, file])
+      await itemManager.setTagParent(parentTag, childTag)
+
+      await itemManager.addTagToFile(file, childTag, false)
+
+      const tags = itemManager.getSortedTagsForItem(file)
+
+      expect(tags).toHaveLength(1)
+      expect(tags[0].uuid).toEqual(childTag.uuid)
+    })
+
+    it('should link file with note', async () => {
+      itemManager = createService()
+      const note = createNote('invoices')
+      const file = createFile('invoice_1.pdf')
+      await itemManager.insertItems([note, file])
+
+      const resultingFile = await itemManager.associateFileWithNote(file, note)
+      const references = resultingFile.references
+
+      expect(references).toHaveLength(1)
+      expect(references[0].uuid).toEqual(note.uuid)
+    })
+
+    it('should unlink file from note', async () => {
+      itemManager = createService()
+      const note = createNote('invoices')
+      const file = createFile('invoice_1.pdf')
+      await itemManager.insertItems([note, file])
+
+      const associatedFile = await itemManager.associateFileWithNote(file, note)
+      const disassociatedFile = await itemManager.disassociateFileWithNote(associatedFile, note)
+      const references = disassociatedFile.references
+
+      expect(references).toHaveLength(0)
+    })
+
+    it('should get files linked with note', async () => {
+      itemManager = createService()
+      const note = createNote('invoices')
+      const file = createFile('invoice_1.pdf')
+      const secondFile = createFile('unrelated-file.xlsx')
+      await itemManager.insertItems([note, file, secondFile])
+
+      await itemManager.associateFileWithNote(file, note)
+
+      const filesAssociatedWithNote = itemManager.getSortedFilesForItem(note)
+
+      expect(filesAssociatedWithNote).toHaveLength(1)
+      expect(filesAssociatedWithNote[0].uuid).toBe(file.uuid)
+    })
+
+    it('should link note to note', async () => {
+      itemManager = createService()
+      const note = createNote('research')
+      const note2 = createNote('citation')
+      await itemManager.insertItems([note, note2])
+
+      const resultingNote = await itemManager.linkNoteToNote(note, note2)
+      const references = resultingNote.references
+
+      expect(references).toHaveLength(1)
+      expect(references[0].uuid).toEqual(note2.uuid)
+    })
+
+    it('should link file to file', async () => {
+      itemManager = createService()
+      const file = createFile('research')
+      const file2 = createFile('citation')
+      await itemManager.insertItems([file, file2])
+
+      const resultingfile = await itemManager.linkFileToFile(file, file2)
+      const references = resultingfile.references
+
+      expect(references).toHaveLength(1)
+      expect(references[0].uuid).toEqual(file2.uuid)
+    })
+
+    it('should get the relationship type for two items', async () => {
+      itemManager = createService()
+      const firstNote = createNote('First note')
+      const secondNote = createNote('Second note')
+      const unlinkedNote = createNote('Unlinked note')
+      await itemManager.insertItems([firstNote, secondNote, unlinkedNote])
+
+      const firstNoteLinkedToSecond = await itemManager.linkNoteToNote(firstNote, secondNote)
+
+      const relationshipOfFirstNoteToSecond = itemManager.relationshipTypeForItems(firstNoteLinkedToSecond, secondNote)
+      const relationshipOfSecondNoteToFirst = itemManager.relationshipTypeForItems(secondNote, firstNoteLinkedToSecond)
+      const relationshipOfFirstNoteToUnlinked = itemManager.relationshipTypeForItems(
+        firstNoteLinkedToSecond,
+        unlinkedNote,
+      )
+
+      expect(relationshipOfFirstNoteToSecond).toBe('direct')
+      expect(relationshipOfSecondNoteToFirst).toBe('indirect')
+      expect(relationshipOfFirstNoteToUnlinked).toBe('unlinked')
+    })
+
+    it('should unlink itemToUnlink from item', async () => {
+      itemManager = createService()
+      const note = createNote('Note 1')
+      const note2 = createNote('Note 2')
+      await itemManager.insertItems([note, note2])
+
+      const linkedItem = await itemManager.linkNoteToNote(note, note2)
+      const unlinkedItem = await itemManager.unlinkItem(linkedItem, note2)
+      const references = unlinkedItem.references
+
+      expect(references).toHaveLength(0)
+    })
+
+    it('should get all linked files for item', async () => {
+      itemManager = createService()
+      const note = createNote('note')
+      const file = createFile('A1')
+      const file2 = createFile('B2')
+
+      await itemManager.insertItems([note, file, file2])
+
+      await itemManager.associateFileWithNote(file2, note)
+      await itemManager.associateFileWithNote(file, note)
+
+      const sortedFilesForItem = itemManager.getSortedFilesForItem(note)
+
+      expect(sortedFilesForItem).toHaveLength(2)
+      expect(sortedFilesForItem[0].uuid).toEqual(file.uuid)
+      expect(sortedFilesForItem[1].uuid).toEqual(file2.uuid)
+    })
+
+    it('should get all linked notes for item', async () => {
+      itemManager = createService()
+      const baseNote = createNote('note')
+      const noteToLink1 = createNote('A1')
+      const noteToLink2 = createNote('B2')
+
+      await itemManager.insertItems([baseNote, noteToLink1, noteToLink2])
+
+      await itemManager.linkNoteToNote(baseNote, noteToLink2)
+      await itemManager.linkNoteToNote(baseNote, noteToLink1)
+
+      const sortedFilesForItem = itemManager.getSortedLinkedNotesForItem(baseNote)
+
+      expect(sortedFilesForItem).toHaveLength(2)
+      expect(sortedFilesForItem[0].uuid).toEqual(noteToLink1.uuid)
+      expect(sortedFilesForItem[1].uuid).toEqual(noteToLink2.uuid)
+    })
+
+    it('should get all notes linking to item', async () => {
+      itemManager = createService()
+      const baseNote = createNote('note')
+      const noteToLink1 = createNote('A1')
+      const noteToLink2 = createNote('B2')
+
+      await itemManager.insertItems([baseNote, noteToLink1, noteToLink2])
+
+      await itemManager.linkNoteToNote(noteToLink2, baseNote)
+      await itemManager.linkNoteToNote(noteToLink1, baseNote)
+
+      const sortedFilesForItem = itemManager.getSortedNotesLinkingToItem(baseNote)
+
+      expect(sortedFilesForItem).toHaveLength(2)
+      expect(sortedFilesForItem[0].uuid).toEqual(noteToLink1.uuid)
+      expect(sortedFilesForItem[1].uuid).toEqual(noteToLink2.uuid)
+    })
+  })
 })
--- a/packages/snjs/lib/Services/Items/ItemManager.ts
+++ b/packages/snjs/lib/Services/Items/ItemManager.ts
@@ -9,7 +9,7 @@ import * as Services from '@standardnotes/services'
 import { PayloadManagerChangeData } from '../Payloads'
 import { DiagnosticInfo, ItemsClientInterface } from '@standardnotes/services'
 import { ApplicationDisplayOptions } from '@Lib/Application/Options/OptionalOptions'
-import { CollectionSort } from '@standardnotes/models'
+import { CollectionSort, DecryptedItemInterface, ItemContent } from '@standardnotes/models'

 type ItemsChangeObserver<I extends Models.DecryptedItemInterface = Models.DecryptedItemInterface> = {
  contentType: ContentType[]
@@ -32,7 +32,7 @@ export class ItemManager
  private observers: ItemsChangeObserver[] = []
  private collection!: Models.ItemCollection
  private systemSmartViews: Models.SmartView[]
-  private tagNotesIndex!: Models.TagNotesIndex
+  private tagItemsIndex!: Models.TagItemsIndex

  private navigationDisplayController!: Models.ItemDisplayController<Models.SNNote | Models.FileItem>
  private tagDisplayController!: Models.ItemDisplayController<Models.SNTag>
@@ -96,7 +96,7 @@ export class ItemManager
      sortDirection: 'asc',
    })

-    this.tagNotesIndex = new Models.TagNotesIndex(this.collection, this.tagNotesIndex?.observers)
+    this.tagItemsIndex = new Models.TagItemsIndex(this.collection, this.tagItemsIndex?.observers)
  }

  private get allDisplayControllers(): Models.ItemDisplayController<Models.DisplayItem>[] {
@@ -219,7 +219,7 @@ export class ItemManager
    ;(this.unsubChangeObserver as unknown) = undefined
    ;(this.payloadManager as unknown) = undefined
    ;(this.collection as unknown) = undefined
-    ;(this.tagNotesIndex as unknown) = undefined
+    ;(this.tagItemsIndex as unknown) = undefined
    ;(this.tagDisplayController as unknown) = undefined
    ;(this.navigationDisplayController as unknown) = undefined
    ;(this.itemsKeyDisplayController as unknown) = undefined
@@ -284,23 +284,23 @@ export class ItemManager
    return TagsToFoldersMigrationApplicator.isApplicableToCurrentData(this)
  }

-  public addNoteCountChangeObserver(observer: Models.TagNoteCountChangeObserver): () => void {
-    return this.tagNotesIndex.addCountChangeObserver(observer)
+  public addNoteCountChangeObserver(observer: Models.TagItemCountChangeObserver): () => void {
+    return this.tagItemsIndex.addCountChangeObserver(observer)
  }

  public allCountableNotesCount(): number {
-    return this.tagNotesIndex.allCountableNotesCount()
+    return this.tagItemsIndex.allCountableItemsCount()
  }

  public countableNotesForTag(tag: Models.SNTag | Models.SmartView): number {
    if (tag instanceof Models.SmartView) {
      if (tag.uuid === Models.SystemViewId.AllNotes) {
-        return this.tagNotesIndex.allCountableNotesCount()
+        return this.tagItemsIndex.allCountableItemsCount()
      }

-      throw Error('countableNotesForTag is not meant to be used for smart views.')
+      throw Error('countableItemsForTag is not meant to be used for smart views.')
    }
-    return this.tagNotesIndex.countableNotesForTag(tag)
+    return this.tagItemsIndex.countableItemsForTag(tag)
  }

  public getNoteCount(): number {
@@ -406,7 +406,7 @@ export class ItemManager
    }

    this.collection.onChange(delta)
-    this.tagNotesIndex.onChange(delta)
+    this.tagItemsIndex.onChange(delta)

    const affectedContentTypesArray = Array.from(affectedContentTypes.values())
    for (const controller of this.allDisplayControllers) {
@@ -1140,20 +1140,97 @@ export class ItemManager
    )
  }

+  public async addTagToFile(file: Models.FileItem, tag: Models.SNTag, addHierarchy: boolean): Promise<Models.SNTag[]> {
+    let tagsToAdd = [tag]
+
+    if (addHierarchy) {
+      const parentChainTags = this.getTagParentChain(tag)
+      tagsToAdd = [...parentChainTags, tag]
+    }
+
+    return Promise.all(
+      tagsToAdd.map((tagToAdd) => {
+        return this.changeTag(tagToAdd, (mutator) => {
+          mutator.addFile(file)
+        }) as Promise<Models.SNTag>
+      }),
+    )
+  }
+
+  public async linkNoteToNote(note: Models.SNNote, otherNote: Models.SNNote): Promise<Models.SNNote> {
+    return this.changeItem<Models.NoteMutator, Models.SNNote>(note, (mutator) => {
+      mutator.addNote(otherNote)
+    })
+  }
+
+  public async linkFileToFile(file: Models.FileItem, otherFile: Models.FileItem): Promise<Models.FileItem> {
+    return this.changeItem<Models.FileMutator, Models.FileItem>(file, (mutator) => {
+      mutator.addFile(otherFile)
+    })
+  }
+
+  public async unlinkItem(
+    item: DecryptedItemInterface<ItemContent>,
+    itemToUnlink: DecryptedItemInterface<ItemContent>,
+  ) {
+    return this.changeItem(item, (mutator) => {
+      mutator.removeItemAsRelationship(itemToUnlink)
+    })
+  }
+
  /**
   * Get tags for a note sorted in natural order
-   * @param note - The note whose tags will be returned
-   * @returns Array containing tags associated with a note
+   * @param item - The item whose tags will be returned
+   * @returns Array containing tags associated with an item
   */
-  public getSortedTagsForNote(note: Models.SNNote): Models.SNTag[] {
+  public getSortedTagsForItem(item: DecryptedItemInterface<ItemContent>): Models.SNTag[] {
    return naturalSort(
-      this.itemsReferencingItem(note).filter((ref) => {
+      this.itemsReferencingItem(item).filter((ref) => {
        return ref?.content_type === ContentType.Tag
      }) as Models.SNTag[],
      'title',
    )
  }

+  public getSortedFilesForItem(item: DecryptedItemInterface<ItemContent>): Models.FileItem[] {
+    if (this.isTemplateItem(item)) {
+      return []
+    }
+
+    const filesReferencingItem = this.itemsReferencingItem(item).filter(
+      (ref) => ref.content_type === ContentType.File,
+    ) as Models.FileItem[]
+    const filesReferencedByItem = this.referencesForItem(item).filter(
+      (ref) => ref.content_type === ContentType.File,
+    ) as Models.FileItem[]
+
+    return naturalSort(filesReferencingItem.concat(filesReferencedByItem), 'title')
+  }
+
+  public getSortedLinkedNotesForItem(item: DecryptedItemInterface<ItemContent>): Models.SNNote[] {
+    if (this.isTemplateItem(item)) {
+      return []
+    }
+
+    const notesReferencedByItem = this.referencesForItem(item).filter(
+      (ref) => ref.content_type === ContentType.Note,
+    ) as Models.SNNote[]
+
+    return naturalSort(notesReferencedByItem, 'title')
+  }
+
+  public getSortedNotesLinkingToItem(item: Models.DecryptedItemInterface<Models.ItemContent>): Models.SNNote[] {
+    if (this.isTemplateItem(item)) {
+      return []
+    }
+
+    const notesReferencingItem = this.itemsReferencingItem(item).filter(
+      (ref) => ref.content_type === ContentType.Note,
+    ) as Models.SNNote[]
+
+    return naturalSort(notesReferencingItem, 'title')
+  }
+
  public async createTag(title: string, parentItemToLookupUuidFor?: Models.SNTag): Promise<Models.SNTag> {
    const newTag = await this.createItem<Models.SNTag>(
      ContentType.Tag,
@@ -1312,12 +1389,6 @@ export class ItemManager
    }
  }

-  public getFilesForNote(note: Models.SNNote): Models.FileItem[] {
-    return (
-      this.itemsReferencingItem(note).filter((ref) => ref.content_type === ContentType.File) as Models.FileItem[]
-    ).sort((a, b) => (a.name.toLowerCase() > b.name.toLowerCase() ? 1 : -1))
-  }
-
  public renameFile(file: Models.FileItem, name: string): Promise<Models.FileItem> {
    return this.changeItem<Models.FileMutator, Models.FileItem>(file, (mutator) => {
      mutator.name = name
@@ -1353,6 +1424,23 @@ export class ItemManager
    return this.findAnyItems(uuids) as (Models.DecryptedItemInterface | Models.DeletedItemInterface)[]
  }

+  /**
+   * @returns `'direct'` if `itemOne` has the reference to `itemTwo`, `'indirect'` if `itemTwo` has the reference to `itemOne`, `'unlinked'` if neither reference each other
+   */
+  public relationshipTypeForItems(
+    itemOne: Models.DecryptedItemInterface<Models.ItemContent>,
+    itemTwo: Models.DecryptedItemInterface<Models.ItemContent>,
+  ): 'direct' | 'indirect' | 'unlinked' {
+    const itemOneReferencesItemTwo = !!this.referencesForItem(itemOne).find(
+      (reference) => reference.uuid === itemTwo.uuid,
+    )
+    const itemTwoReferencesItemOne = !!this.referencesForItem(itemTwo).find(
+      (reference) => reference.uuid === itemOne.uuid,
+    )
+
+    return itemOneReferencesItemTwo ? 'direct' : itemTwoReferencesItemOne ? 'indirect' : 'unlinked'
+  }
+
  override getDiagnostics(): Promise<DiagnosticInfo | undefined> {
    return Promise.resolve({
      items: {
--- a/packages/snjs/mocha/item_manager.test.js
+++ b/packages/snjs/mocha/item_manager.test.js
@@ -570,7 +570,7 @@ describe('item manager', function () {
        })
      })

-      const results = this.itemManager.getSortedTagsForNote(note)
+      const results = this.itemManager.getSortedTagsForItem(note)

      expect(results).lengthOf(tags.length)
      expect(results[0].title).to.equal(tags[1].title)
--- a/packages/snjs/mocha/model_tests/notes_tags_folders.test.js
+++ b/packages/snjs/mocha/model_tests/notes_tags_folders.test.js
@@ -77,8 +77,8 @@ describe('tags as folders', () => {
    await this.application.items.addTagToNote(note2, tags.another, true)

    // ## The note has been added to other tags
-    const note1Tags = await this.application.items.getSortedTagsForNote(note1)
-    const note2Tags = await this.application.items.getSortedTagsForNote(note2)
+    const note1Tags = await this.application.items.getSortedTagsForItem(note1)
+    const note2Tags = await this.application.items.getSortedTagsForItem(note2)

    expect(note1Tags.length).to.equal(3)
    expect(note2Tags.length).to.equal(1)