notu 0.1.0

package/src/models/Note.test.ts

@@ -0,0 +1,322 @@
+import { expect, test } from 'vitest';
+import Note from './Note';
+import Tag from './Tag';
+import Space from './Space';
+
+
+function newCleanTag(): Tag {
+    const tag = new Tag('hello');
+    tag.id = 123;
+    tag.clean();
+    return tag;
+}
+
+
+test('gets initiated with sensible defaults', () => {
+    const note = new Note();
+    expect(note.id).toBe(0);
+    expect(note.date.getTime() / 1000).toBeCloseTo(new Date().getTime() / 1000);
+    expect(note.text).toBe('');
+    expect(note.archived).toBe(false);
+    expect(note.spaceId).toBe(0);
+});
+
+test('can duplicate itself', () => {
+    const note = new Note().clean();
+    const space = new Space('hello');
+    space.id = 123;
+    note.space = space;
+    const copy = note.duplicate();
+    expect(copy.id).toBe(note.id);
+    expect(copy.date).toBe(note.date);
+    expect(copy.text).toBe(note.text);
+    expect(copy.archived).toBe(note.archived);
+    expect(copy.space).toBe(note.space);
+    expect(copy.spaceId).toBe(note.spaceId);
+    expect(copy.state).toBe(note.state);
+});
+
+test('Gets initiated as new', () => {
+    const note = new Note();
+    expect(note.isNew).toBe(true);
+});
+
+
+test('Set date marks note as dirty if currently clean', () => {
+    const note = new Note().clean();
+    note.date = new Date();
+    expect(note.isDirty).toBe(true);
+});
+
+test('Set date doesnt change note state if new', () => {
+    const note = new Note().new();
+    note.date = new Date();
+    expect(note.isNew).toBe(true);
+});
+
+test('Set date doesnt change note state if value not different', () => {
+    const note = new Note().clean();
+    note.date = note.date;
+    expect(note.isClean).toBe(true);
+});
+
+
+test('Set text marks note as dirty if currently clean', () => {
+    const note = new Note().clean();
+    note.text = 'asdf';
+    expect(note.isDirty).toBe(true);
+});
+
+test('Set text doesnt change note state if new', () => {
+    const note = new Note().new();
+    note.text = 'asdf';
+    expect(note.isNew).toBe(true);
+});
+
+test('Set text doesnt change note state if value not different', () => {
+    const note = new Note().clean();
+    note.text = '';
+    expect(note.isClean).toBe(true);
+});
+
+
+test('Set archived marks note as dirty if currently clean', () => {
+    const note = new Note().clean();
+    note.archived = !note.archived;
+    expect(note.isDirty).toBe(true);
+});
+
+test('Set archived doesnt change note state if new', () => {
+    const note = new Note().new();
+    note.archived = !note.archived;
+    expect(note.isNew).toBe(true);
+});
+
+test('Set archived doesnt change note state if value not different', () => {
+    const note = new Note().clean();
+    note.archived = note.archived;
+    expect(note.isClean).toBe(true);
+});
+
+
+test('Set spaceId marks note as dirty if currently clean', () => {
+    const note = new Note().clean();
+    note.spaceId = 123;
+    expect(note.isDirty).toBe(true);
+});
+
+test('Set spaceId doesnt change note state if new', () => {
+    const note = new Note().new();
+    note.spaceId = 123;
+    expect(note.isNew).toBe(true);
+});
+
+test('Set spaceId doesnt change note state if value not different', () => {
+    const note = new Note().clean();
+    note.spaceId = note.spaceId;
+    expect(note.isClean).toBe(true);
+});
+
+test('setOwnTag doesnt mark note as dirty', () => {
+    const note = new Note().clean().setOwnTag('hello');
+    expect(note.isClean).toBe(true);
+});
+
+test('setOwnTag with string creates tag with same id as note', () => {
+    const note = new Note();
+    note.id = 123;
+    note.setOwnTag('hello');
+    expect(note.ownTag.id).toBe(note.id);
+});
+
+test('setOwnTag can take tag object, rather than just name', () => {
+    const note = new Note().setOwnTag(new Tag('hello'));
+    expect(note.ownTag.name).toBe('hello');
+});
+
+test('setOwnTag with tag object will throw error if tag already set', () => {
+    const note = new Note().setOwnTag('hello');
+    expect(() => note.setOwnTag(new Tag('goodbye'))).toThrowError();
+});
+
+test('setOwnTag with tag object will throw error if tag id is non-zero and doesnt match note id', () => {
+    const note = new Note().clean();
+    note.id = 123;
+    const tag = new Tag('hello');
+    tag.id = 57;
+    expect(() => note.setOwnTag(tag)).toThrowError();
+});
+
+test('removeOwnTag marks existing tag as deleted if clean', () => {
+    const note = new Note().setOwnTag('hello');
+    note.ownTag.clean();
+    note.removeOwnTag();
+    expect(note.ownTag.isDeleted).toBe(true);
+});
+
+test('removeOwnTag nulls out new tag', () => {
+    const note = new Note().setOwnTag('hello');
+    note.removeOwnTag();
+    expect(note.ownTag).toBeNull();
+});
+
+test('Setting space with id different than current spaceId updates state', () => {
+    const note = new Note();
+    note.spaceId = 57;
+    note.clean();
+    const space = new Space('hello');
+    space.id = 60;
+
+    note.space = space;
+
+    expect(note.spaceId).toBe(60);
+    expect(note.isDirty).toBe(true);
+});
+
+test('Setting space with id same as current spaceId preserves state', () => {
+    const note = new Note();
+    note.spaceId = 80;
+    note.clean();
+    const space = new Space('hello');
+    space.id = 80;
+
+    note.space = space;
+
+    expect(note.spaceId).toBe(80);
+    expect(note.isClean).toBe(true);
+});
+
+test('Setting spaceId to new value removes space object', () => {
+    const note = new Note();
+    const space = new Space('hello');
+    space.id = 80;
+    note.space = space;
+
+    note.spaceId = 81;
+
+    expect(note.space).toBeNull();
+});
+
+test('Setting spaceId to same as current space id preserves it', () => {
+    const note = new Note();
+    const space = new Space('hello');
+    space.id = 80;
+    note.space = space;
+    
+    note.spaceId = 80;
+
+    expect(note.space.name).toBe('hello');
+});
+
+
+test('validate fails if spaceId is 0', () => {
+    const model = new Note();
+    model.spaceId = 0;
+    expect(model.validate()).toBe(false);
+});
+
+test('validate fails if not new and id <= 0', () => {
+    const model = new Note().clean();
+    model.id = 0;
+    model.spaceId = 123;
+    expect(model.validate()).toBe(false);
+});
+
+test('validate throws error if arg set to true', () => {
+    const model = new Note();
+    model.spaceId = 0;
+    expect(() => model.validate(true)).toThrowError();
+});
+
+test('validate calls validate on ownTag', () => {
+    const note = new Note().setOwnTag('asdf');
+    note.spaceId = 123;
+    expect(note.validate()).toBe(true);
+    note.ownTag.clean();
+    expect(note.validate()).toBe(false);
+});
+
+test('validate calls validate on each added tag', () => {
+    const note = new Note();
+    note.spaceId = 123;
+    const nt = note.addTag(newCleanTag());
+    expect(note.validate()).toBe(true);
+    nt.tagId = 0;
+    expect(note.validate()).toBe(false);
+});
+
+
+test('addTag adds new NoteTag object', () => {
+    const tag = newCleanTag();
+    const note = new Note();
+
+    note.addTag(tag);
+
+    expect(note.tags.length).toBe(1);
+    expect(note.tags[0].note).toBe(note);
+    expect(note.tags[0].tag).toBe(tag);
+});
+
+test('addTag returns existing NoteTag object if trying to add duplicate tag', () => {
+    const tag = newCleanTag();
+    const note = new Note();
+    note.addTag(tag);
+
+    note.addTag(tag);
+
+    expect(note.tags.length).toBe(1);
+    expect(note.tags[0].note).toBe(note);
+    expect(note.tags[0].tag).toBe(tag);
+});
+
+test('addTag undeletes existing NoteTag if trying to add duplicate tag', () => {
+    const tag = newCleanTag();
+    const note = new Note();
+    const nt = note.addTag(tag);
+    nt.delete();
+
+    note.addTag(tag);
+
+    expect(note.tags.length).toBe(1);
+    expect(nt.isDirty).toBe(true);
+});
+
+test('addTag throws error if trying to add deleted tag', () => {
+    const tag = newCleanTag().delete();
+    const note = new Note();
+    expect(() => note.addTag(tag)).toThrowError();
+});
+
+test('addTag prevents note from adding its own tag', () => {
+    const note = new Note();
+    note.id = 123;
+    note.setOwnTag('test');
+
+    expect(() => note.addTag(note.ownTag)).toThrowError();
+});
+
+test('addTag prevents note from adding tag that hasnt been saved yet', () => {
+    const note = new Note();
+    expect(() => note.addTag(new Tag())).toThrowError();
+});
+
+test('removeTag removes newly added tag from note', () => {
+    const tag = newCleanTag();
+    const note = new Note();
+    note.addTag(tag);
+
+    note.removeTag(tag);
+
+    expect(note.tags.length).toBe(0);
+});
+
+test('removeTag marks existing tag on note as deleted', () => {
+    const tag = newCleanTag();
+    const note = new Note();
+    note.addTag(tag).clean();
+
+    note.removeTag(tag);
+
+    expect(note.tags.length).toBe(1);
+    expect(note.tags[0].isDeleted).toBe(true);
+});

package/src/models/Note.ts

@@ -0,0 +1,164 @@
+'use strict';
+
+import ModelWithState from './ModelWithState';
+import NoteTag from './NoteTag';
+import Space from './Space';
+import Tag from './Tag';
+
+
+export default class Note extends ModelWithState<Note> {
+    id: number = 0;
+
+
+    private _date: Date = new Date();
+    get date(): Date { return this._date; }
+    set date(value: Date) {
+        if (value !== this._date) {
+            this._date = value;
+            if (this.isClean)
+                this.dirty();
+        }
+    }
+
+
+    private _text: string = '';
+    get text(): string { return this._text; }
+    set text(value: string) {
+        if (value !== this._text) {
+            this._text = value;
+            if (this.isClean)
+                this.dirty();
+        }
+    }
+
+
+    private _archived: boolean = false;
+    get archived(): boolean { return this._archived; }
+    set archived(value: boolean) {
+        if (value !== this._archived) {
+            this._archived = value;
+            if (this.isClean)
+                this.dirty();
+        }
+    }
+
+
+    private _spaceId: number = 0;
+    get spaceId(): number { return this._spaceId; }
+    set spaceId(value: number) {
+        if (value !== this._spaceId) {
+            this._spaceId = value;
+            if (value !== this.space?.id ?? 0)
+                this._space = null;
+            if (this.isClean)
+                this.dirty();
+        }
+    }
+
+    private _space: Space = null;
+    get space(): Space { return this._space; }
+    set space(value: Space) {
+        this._space = value;
+        this.spaceId = value?.id ?? 0;
+    }
+
+
+    private _ownTag: Tag = null;
+    get ownTag(): Tag { return this._ownTag; }
+
+    setOwnTag(tag: string | Tag): Note {
+        if (typeof tag === 'string') {
+            if (this.ownTag == null)
+                this._ownTag = new Tag();
+            this.ownTag.name = tag;
+            this.ownTag.id = this.id;
+        }
+        else {
+            if (!!this.ownTag)
+                throw new Error('Note has already had its tag set. If you would like to change the tag name, call setTag with just a string specifying the new tag name.');
+            if (tag.id != 0 && tag.id != this.id)
+                throw new Error('Attempted to set tag to note with non-matching ID. Added tag id must either match the note id, which indicates that the tag has already been added to the note. Otherwise the tag id must be zero, indicating that the tag still needs to be added.')
+            this._ownTag = tag;
+        }
+        return this;
+    }
+
+    removeOwnTag(): Note {
+        if (!this.ownTag)
+            return;
+        if (this.ownTag.isNew)
+            this._ownTag = null;
+        else
+            this.ownTag.delete();
+    }
+
+
+    private _tags: Array<NoteTag> = [];
+    get tags(): Array<NoteTag> { return this._tags; }
+
+    addTag(tag: Tag): NoteTag {
+        if (tag.isDeleted)
+            throw Error('Cannot add a tag marked as deleted to a note');
+        if (tag.isNew)
+            throw Error('Cannot add a tag that hasn\'t yet been saved to a note');
+        if (tag.id == this.id)
+            throw Error('Note cannot add its own tag as a linked tag');
+        let nt = this.tags.find(x => x.tagId == tag.id);
+        if (!!nt) {
+            if (nt.isDeleted)
+                nt.dirty();
+            return nt;
+        }
+        nt = new NoteTag();
+        nt.note = this;
+        nt.tag = tag;
+        this._tags.push(nt);
+        return nt;
+    }
+
+    removeTag(tag: Tag): Note {
+        const nt = this.tags.find(x => x.tagId == tag.id);
+        if (!nt)
+            return this;
+
+        if (nt.isNew)
+            this._tags = this._tags.filter(x => x !== nt);
+        else
+            nt.delete();
+        return this;
+    }
+
+
+    duplicate(): Note {
+        const output = new Note();
+        output.id = this.id;
+        output.date = this.date;
+        output.text = this.text;
+        output.archived = this.archived;
+        output.space = this.space;
+        output.state = this.state;
+        return output;
+    }
+
+
+    validate(throwError: boolean = false): boolean {
+        let output = null;
+
+        if (this.spaceId <= 0)
+            output = 'Note spaceId must be greater than zero.';
+        else if (!this.isNew && this.id <= 0)
+            output = 'Note id must be greater than zero if in non-new state.';
+
+        if (throwError && output != null)
+            throw Error(output);
+
+        if (!!this.ownTag && !this.ownTag.validate(throwError))
+            return false;
+        for (const nt of this.tags) {
+            if (!nt.validate(throwError))
+                return false;
+        }
+
+        return output == null;
+    }
+}

package/src/models/NoteTag.test.ts

@@ -0,0 +1,200 @@
+import { expect, test } from 'vitest';
+import NoteTag from './NoteTag';
+import Note from './Note';
+import Tag from './Tag';
+
+
+test('Gets initiated as new', () => {
+    const nt = new NoteTag();
+    expect(nt.isNew).toBe(true);
+});
+
+test('Gets initiated with sensible defaults', () => {
+    const nt = new NoteTag();
+    expect(nt.noteId).toBe(0);
+    expect(nt.tagId).toBe(0);
+});
+
+test('Can duplicate itself', () => {
+    const nt = new NoteTag();
+    nt.noteId = 123;
+    nt.tagId = 234;
+    const copy = nt.duplicate();
+    expect(copy.noteId).toBe(nt.noteId);
+    expect(copy.tagId).toBe(nt.tagId);
+});
+
+
+test('Set noteId marks object as dirty if currently clean', () => {
+    const nt = new NoteTag().clean();
+    nt.noteId = 123;
+    expect(nt.isDirty).toBe(true);
+});
+
+test('Set noteId doesnt change state if new', () => {
+    const nt = new NoteTag().new();
+    nt.noteId = 123;
+    expect(nt.isNew).toBe(true);
+});
+
+test('Set noteId doesnt change state if value not different', () => {
+    const nt = new NoteTag().clean();
+    nt.noteId = nt.noteId;
+    expect(nt.isClean).toBe(true);
+});
+
+
+test('Set tagId marks object as dirty if currently clean', () => {
+    const nt = new NoteTag().clean();
+    nt.tagId = 123;
+    expect(nt.isDirty).toBe(true);
+});
+
+test('Set tagId doesnt change state if new', () => {
+    const nt = new NoteTag().new();
+    nt.tagId = 123;
+    expect(nt.isNew).toBe(true);
+});
+
+test('Set tagId doesnt change state if value not different', () => {
+    const nt = new NoteTag().clean();
+    nt.tagId = nt.tagId;
+    expect(nt.isClean).toBe(true);
+});
+
+
+test('Setting note with id different than current noteId updates state', () => {
+    const nt = new NoteTag();
+    nt.noteId = 123;
+    nt.clean();
+    const note = new Note();
+    note.id = 234;
+
+    nt.note = note;
+
+    expect(nt.noteId).toBe(234);
+    expect(nt.isDirty).toBe(true);
+});
+
+test('Setting note with id same as current noteId preserves state', () => {
+    const nt = new NoteTag();
+    nt.noteId = 27;
+    nt.clean();
+    const note = new Note();
+    note.id = 27;
+
+    nt.note = note;
+
+    expect(nt.noteId).toBe(27);
+    expect(nt.isClean).toBe(true);
+});
+
+test('Setting noteId to new value removes note object', () => {
+    const nt = new NoteTag();
+    const note = new Note();
+    note.id = 80;
+    nt.note = note;
+
+    nt.noteId = 81;
+
+    expect(nt.note).toBeNull();
+});
+
+test('Setting noteId to same as current note id preserves it', () => {
+    const nt = new NoteTag();
+    const note = new Note();
+    note.id = 80;
+    nt.note = note;
+
+    nt.noteId = 80;
+
+    expect(nt.note).not.toBeNull();
+});
+
+
+test('Setting tag with id different than current tagId updates state', () => {
+    const nt = new NoteTag();
+    nt.tagId = 123;
+    nt.clean();
+    const tag = new Tag();
+    tag.id = 234;
+
+    nt.tag = tag;
+
+    expect(nt.tagId).toBe(234);
+    expect(nt.isDirty).toBe(true);
+});
+
+test('Setting tag with id same as current tagId preserves state', () => {
+    const nt = new NoteTag();
+    nt.tagId = 27;
+    nt.clean();
+    const tag = new Tag();
+    tag.id = 27;
+
+    nt.tag = tag;
+
+    expect(nt.tagId).toBe(27);
+    expect(nt.isClean).toBe(true);
+});
+
+test('Setting tagId to new value removes tag object', () => {
+    const nt = new NoteTag();
+    const tag = new Tag();
+    tag.id = 80;
+    nt.tag = tag;
+
+    nt.tagId = 81;
+
+    expect(nt.tag).toBeNull();
+});
+
+test('Setting tagId to same as current tag id preserves it', () => {
+    const nt = new NoteTag();
+    const tag = new Tag();
+    tag.id = 80;
+    nt.tag = tag;
+
+    nt.tagId = 80;
+
+    expect(nt.tag).not.toBeNull();
+});
+
+
+test('validate passes if noteId is 0 and state is new', () => {
+    const nt = new NoteTag();
+    nt.tagId = 123;
+    expect(nt.validate()).toBe(true);
+});
+
+test('validate fails if noteId is 0 and state is not new', () => {
+    const nt = new NoteTag();
+    nt.tagId = 123;
+    nt.clean();
+    expect(nt.validate()).toBe(false);
+});
+
+test('validate fails if tagId is 0', () => {
+    const nt = new NoteTag();
+    nt.noteId = 123;
+    expect(nt.validate()).toBe(false);
+});
+
+test('validate throws error if arg set to true', () => {
+    const nt = new NoteTag();
+    expect(() => nt.validate(true)).toThrowError();
+});
+
+test('validate fails if noteId = tagId', () => {
+    const nt = new NoteTag();
+    nt.noteId = 123;
+    nt.tagId = 123;
+    expect(nt.validate()).toBe(false);
+});
+
+test('validate succeeds if noteId & tagId are both positive, different values', () => {
+    const nt = new NoteTag();
+    nt.noteId = 123;
+    nt.tagId = 234;
+    expect(nt.validate()).toBe(true);
+});