diff --git a/internal/vault/note_metadata.go b/internal/vault/note_metadata.go index 9c4faa0..1db70ce 100644 --- a/internal/vault/note_metadata.go +++ b/internal/vault/note_metadata.go @@ -7,6 +7,7 @@ import ( "os" "path/filepath" "strings" + "time" ) const noteMetadataDir = "note-metadata" @@ -64,7 +65,12 @@ func (v *Vault) writeNoteFileAtomic(abs string, data []byte) error { // before replacing the note, so a new inode cannot seed a newer date here. info, err := os.Stat(abs) if errors.Is(err, os.ErrNotExist) { - if err := os.Remove(metadataPath); err != nil && !errors.Is(err, os.ErrNotExist) { + // A new note records now rather than leaving its date to the file's + // birthtime. On NTFS a file made under a name deleted in the last 15 + // seconds gets the deleted file's birthtime back (file system + // tunneling), and the next save would write that date down for good. + // This replaces any record an earlier note of the name left behind. + if err := v.writeCreationMetadata(metadataPath, time.Now().UnixMilli()); err != nil { return err } } else if err != nil { @@ -76,12 +82,7 @@ func (v *Vault) writeNoteFileAtomic(abs string, data []byte) error { return err } if created == 0 { - created = originalCreatedAt - raw, err := json.Marshal(noteCreationMetadata{Version: 1, CreatedAt: created}) - if err != nil { - return err - } - if err := writeFileAtomic(metadataPath, append(raw, '\n'), v.fileMode, v.dirMode); err != nil { + if err := v.writeCreationMetadata(metadataPath, originalCreatedAt); err != nil { return err } } @@ -89,6 +90,14 @@ func (v *Vault) writeNoteFileAtomic(abs string, data []byte) error { return writeFileAtomic(abs, data, v.fileMode, v.dirMode) } +func (v *Vault) writeCreationMetadata(metadataPath string, createdAt int64) error { + raw, err := json.Marshal(noteCreationMetadata{Version: 1, CreatedAt: createdAt}) + if err != nil { + return err + } + return writeFileAtomic(metadataPath, append(raw, '\n'), v.fileMode, v.dirMode) +} + // Move the sidecar in the same transaction as its note or folder. If metadata // cannot move, keep the content at its original path rather than losing its date. func (v *Vault) relocateWithMetadata(from, to string, directory bool) error { diff --git a/internal/vault/note_metadata_test.go b/internal/vault/note_metadata_test.go index 31d5ef7..29cf518 100644 --- a/internal/vault/note_metadata_test.go +++ b/internal/vault/note_metadata_test.go @@ -4,6 +4,7 @@ import ( "os" "path/filepath" "testing" + "time" ) const originalCreatedAt int64 = 1600000000123 @@ -82,6 +83,55 @@ func TestNoteCreationMetadataSurvivesWritesAndLifecycle(t *testing.T) { } } +// On NTFS a file made under a name deleted in the last 15 seconds gets the +// deleted file's birthtime back (file system tunneling), so a new note's date +// cannot come from the file. Each way of making one records it in the sidecar +// at once, and the first save keeps that record. +func TestNewNoteRecordsItsOwnCreationDate(t *testing.T) { + create := map[string]func(v *Vault) (NoteMeta, error){ + "CreateNote": func(v *Vault) (NoteMeta, error) { return v.CreateNote(FolderInbox, "Original", "", nil) }, + "WriteNote": func(v *Vault) (NoteMeta, error) { return v.WriteNote("inbox/Original.md", "# Original\n") }, + } + for name, make := range create { + t.Run(name, func(t *testing.T) { + v := newTestVault(t) + rel := "inbox/Original.md" + writeFile(t, filepath.Join(v.root, rel), "# Original\n") + seedNoteMetadata(t, v, rel) + if err := v.DeleteNote(rel); err != nil { + t.Fatal(err) + } + before := time.Now().UnixMilli() + meta, err := make(v) + after := time.Now().UnixMilli() + if err != nil { + t.Fatal(err) + } + if meta.Path != rel { + t.Fatalf("path = %s, want %s", meta.Path, rel) + } + sidecar := filepath.Join(v.root, ".zennotes", "note-metadata", rel+".metadata.json") + recorded, err := readCreationMetadata(sidecar) + if err != nil { + t.Fatal(err) + } + if recorded < before || recorded > after { + t.Fatalf("recorded createdAt = %d, want between %d and %d", recorded, before, after) + } + if meta.CreatedAt != recorded { + t.Fatalf("createdAt = %d, want the recorded %d", meta.CreatedAt, recorded) + } + saved, err := v.WriteNote(rel, "# Original\n\nEdited.\n") + if err != nil { + t.Fatal(err) + } + if saved.CreatedAt != recorded { + t.Fatalf("after a save createdAt = %d, want %d", saved.CreatedAt, recorded) + } + }) + } +} + func TestNoteMetadataCorruptionDoesNotMutateNote(t *testing.T) { v := newTestVault(t) rel := "inbox/Original.md"