notu 0.1.0 → 0.2.1

package/src/models/NoteAttr.test.ts

@@ -0,0 +1,358 @@
+import { expect, test } from 'vitest';
+import NoteAttr from './NoteAttr';
+import Note from './Note';
+import Attr from './Attr';
+import Tag from './Tag';
+
+
+test('Gets initiated as new', () => {
+    const na = new NoteAttr();
+    expect(na.isNew).toBe(true);
+});
+
+test('Gets initiated with sensible defaults', () => {
+    const na = new NoteAttr();
+    expect(na.noteId).toBe(0);
+    expect(na.attrId).toBe(0);
+    expect(na.value).toBe(null);
+    expect(na.tagId).toBe(null);
+});
+
+
+test('Set noteId marks object as dirty if currently clean', () => {
+    const na = new NoteAttr().clean();
+    na.noteId = 123;
+    expect(na.isDirty).toBe(true);
+});
+
+test('Set noteId doesnt change state if new', () => {
+    const na = new NoteAttr().new();
+    na.noteId = 123;
+    expect(na.isNew).toBe(true);
+});
+
+test('Set noteId doesnt change state if value not different', () => {
+    const na = new NoteAttr().clean();
+    na.noteId = na.noteId;
+    expect(na.isClean).toBe(true);
+});
+
+test('Setting note with id different than current noteId updates state', () => {
+    const na = new NoteAttr();
+    na.noteId = 123;
+    na.clean();
+    const note = new Note();
+    note.id = 234;
+
+    na.note = note;
+
+    expect(na.noteId).toBe(234);
+    expect(na.isDirty).toBe(true);
+});
+
+test('Setting note with id same as current noteId preserves state', () => {
+    const na = new NoteAttr();
+    na.noteId = 27;
+    na.clean();
+    const note = new Note();
+    note.id = 27;
+
+    na.note = note;
+
+    expect(na.noteId).toBe(27);
+    expect(na.isClean).toBe(true);
+});
+
+test('Setting noteId to new value removes note object', () => {
+    const na = new NoteAttr();
+    const note = new Note();
+    note.id = 80;
+    na.note = note;
+
+    na.noteId = 81;
+
+    expect(na.note).toBeNull();
+});
+
+test('Setting noteId to same as current note id preserves it', () => {
+    const na = new NoteAttr();
+    const note = new Note();
+    note.id = 80;
+    na.note = note;
+
+    na.noteId = 80;
+
+    expect(na.note).not.toBeNull();
+});
+
+
+test('Set attrId marks object as dirty if currently clean', () => {
+    const na = new NoteAttr().clean();
+    na.attrId = 123;
+    expect(na.isDirty).toBe(true);
+});
+
+test('Set attrId doesnt change state if new', () => {
+    const na = new NoteAttr().new();
+    na.attrId = 123;
+    expect(na.isNew).toBe(true);
+});
+
+test('Set attrId doesnt change state if value not different', () => {
+    const na = new NoteAttr().clean();
+    na.attrId = na.attrId;
+    expect(na.isClean).toBe(true);
+});
+
+test('Setting attr with id different than current attrId updates state', () => {
+    const na = new NoteAttr();
+    na.attrId = 123;
+    na.clean();
+    const attr = new Attr();
+    attr.id = 234;
+
+    na.attr = attr;
+
+    expect(na.attrId).toBe(234);
+    expect(na.isDirty).toBe(true);
+});
+
+test('Setting attr with id same as current attrId preserves state', () => {
+    const na = new NoteAttr();
+    na.attrId = 27;
+    na.value = '';
+    na.clean();
+    const attr = new Attr();
+    attr.id = 27;
+
+    na.attr = attr;
+
+    expect(na.attrId).toBe(27);
+    expect(na.isClean).toBe(true);
+});
+
+test('Setting attrId to new value removes attr object', () => {
+    const na = new NoteAttr();
+    const attr = new Attr();
+    attr.id = 80;
+    na.attr = attr;
+
+    na.attrId = 81;
+
+    expect(na.attr).toBeNull();
+});
+
+test('Setting attrId to same as current attr id preserves it', () => {
+    const na = new NoteAttr();
+    const attr = new Attr();
+    attr.id = 80;
+    na.attr = attr;
+
+    na.attrId = 80;
+
+    expect(na.attr).not.toBeNull();
+});
+
+test('Setting attr updates the default value', () => {
+    const na = new NoteAttr();
+    const attr1 = new Attr().asNumber();
+    attr1.id = 1;
+
+    na.attr = attr1;
+
+    expect(na.value).toBe(0);
+});
+
+test('Setting attr to null clears out value', () => {
+    const na = new NoteAttr();
+    const attr = new Attr().asNumber();
+    attr.id = 1;
+    na.attr = attr;
+
+    na.attr = null;
+
+    expect(na.value).toBe(null);
+});
+
+test('Setting attr to new value of same type doesnt update value', () => {
+    const na = new NoteAttr();
+    const attr1 = new Attr().asNumber();
+    const attr2 = new Attr().asNumber();
+    attr1.id = 1;
+    attr2.id = 2;
+    na.attr = attr1;
+    na.value = 123;
+
+    na.attr = attr2;
+
+    expect(na.value).toBe(123);
+});
+
+test('Setting attr to new value of different type does update value', () => {
+    const na = new NoteAttr();
+    const attr1 = new Attr().asNumber();
+    const attr2 = new Attr().asText();
+    attr1.id = 1;
+    attr2.id = 2;
+    na.attr = attr1;
+    na.value = 123;
+
+    na.attr = attr2;
+
+    expect(na.value).toBe('');
+});
+
+
+test('Set value marks object as dirty if currently clean', () => {
+    const na = new NoteAttr().clean();
+    na.value = 123;
+    expect(na.isDirty).toBe(true);
+});
+
+test('Set value doesnt change state if new', () => {
+    const na = new NoteAttr().new();
+    na.value = 123;
+    expect(na.isNew).toBe(true);
+});
+
+test('Set value doesnt change state if value not different', () => {
+    const na = new NoteAttr().clean();
+    na.value = na.value;
+    expect(na.isClean).toBe(true);
+});
+
+
+test('Set tagId marks object as dirty if currently clean', () => {
+    const na = new NoteAttr().clean();
+    na.tagId = 123;
+    expect(na.isDirty).toBe(true);
+});
+
+test('Set tagId doesnt change state if new', () => {
+    const na = new NoteAttr().new();
+    na.tagId = 123;
+    expect(na.isNew).toBe(true);
+});
+
+test('Set tagId doesnt change state if value not different', () => {
+    const na = new NoteAttr().clean();
+    na.tagId = na.tagId;
+    expect(na.isClean).toBe(true);
+});
+
+test('Setting tag with id different than current tagId updates state', () => {
+    const na = new NoteAttr();
+    na.tagId = 123;
+    na.clean();
+    const tag = new Tag();
+    tag.id = 234;
+
+    na.tag = tag;
+
+    expect(na.tagId).toBe(234);
+    expect(na.isDirty).toBe(true);
+});
+
+test('Setting tag with id same as current tagId preserves state', () => {
+    const na = new NoteAttr();
+    na.tagId = 27;
+    na.clean();
+    const tag = new Tag();
+    tag.id = 27;
+
+    na.tag = tag;
+
+    expect(na.tagId).toBe(27);
+    expect(na.isClean).toBe(true);
+});
+
+test('Setting tagId to new value removes tag object', () => {
+    const na = new NoteAttr();
+    const tag = new Tag();
+    tag.id = 80;
+    na.tag = tag;
+
+    na.tagId = 81;
+
+    expect(na.tag).toBeNull();
+});
+
+test('Setting tagId to same as current tag id preserves it', () => {
+    const na = new NoteAttr();
+    const tag = new Tag();
+    tag.id = 80;
+    na.tag = tag;
+
+    na.tagId = 80;
+
+    expect(na.tag).not.toBeNull();
+});
+
+test('Setting tag to null also nulls tagId', () => {
+    const na = new NoteAttr();
+    const tag = new Tag();
+    tag.id = 80;
+    na.tag = tag;
+    expect(na.tagId).toBe(80);
+
+    na.tag = null;
+
+    expect(na.tagId).toBe(null);
+});
+
+
+test('Can duplicate itself', () => {
+    const na = new NoteAttr();
+    const note = new Note();
+    note.id = 24;
+    const attr = new Attr();
+    attr.id = 25;
+    const tag = new Tag();
+    tag.id = 26;
+    na.note = note;
+    na.attr = attr;
+    na.tag = tag;
+    na.value = 'hello';
+
+    const copy = na.duplicate();
+
+    expect(copy.note).toBe(na.note);
+    expect(copy.noteId).toBe(na.noteId);
+    expect(copy.attr).toBe(na.attr);
+    expect(copy.attrId).toBe(na.attrId);
+    expect(copy.tag).toBe(na.tag);
+    expect(copy.tagId).toBe(na.tagId);
+    expect(copy.value).toBe(na.value);
+});
+
+
+test('validate passes if noteId is 0 and state is new', () => {
+    const nt = new NoteAttr();
+    nt.attrId = 123;
+    expect(nt.validate()).toBe(true);
+});
+
+test('validate fails if noteId is 0 and state is not new', () => {
+    const nt = new NoteAttr();
+    nt.attrId = 123;
+    nt.clean();
+    expect(nt.validate()).toBe(false);
+});
+
+test('validate fails if attrId is 0', () => {
+    const nt = new NoteAttr();
+    nt.noteId = 123;
+    expect(nt.validate()).toBe(false);
+});
+
+test('validate throws error if arg set to true', () => {
+    const nt = new NoteAttr();
+    expect(() => nt.validate(true)).toThrowError();
+});
+
+test('validate succeeds if noteId & attrId are both positive values', () => {
+    const nt = new NoteAttr();
+    nt.noteId = 123;
+    nt.attrId = 234;
+    expect(nt.validate()).toBe(true);
+});

package/src/models/NoteAttr.ts

@@ -0,0 +1,113 @@
+'use strict';
+
+import ModelWithState from './ModelWithState';
+import Note from './Note';
+import Attr from './Attr';
+import Tag from './Tag';
+
+
+export default class NoteAttr extends ModelWithState<NoteAttr> {
+    private _noteId: number = 0;
+    get noteId(): number { return this._noteId; }
+    set noteId(value: number) {
+        if (value !== this._noteId) {
+            this._noteId = value;
+            if (value !== this.note?.id ?? 0)
+                this._note = null;
+            if (this.isClean)
+                this.dirty();
+        }
+    }
+
+    private _note: Note = null;
+    get note(): Note { return this._note; }
+    set note(value: Note) {
+        this._note = value;
+        this.noteId = value?.id ?? 0;
+    }
+
+
+    private _attrId: number = 0;
+    get attrId(): number { return this._attrId; }
+    set attrId(value: number) {
+        if (value !== this._attrId) {
+            this._attrId = value;
+            if (value !== this.attr?.id ?? 0)
+                this._attr = null;
+            if (this.isClean)
+                this.dirty();
+        }
+    }
+
+    private _attr: Attr = null;
+    get attr(): Attr { return this._attr; }
+    set attr(newAttr: Attr) {
+        const oldAttr = this._attr;
+        this._attr = newAttr;
+        if (!!newAttr) {
+            if (!oldAttr || newAttr.type != oldAttr.type)
+                this.value = newAttr.defaultValue;
+        }
+        else
+            this.value = null;
+        this.attrId = newAttr?.id ?? 0;
+    }
+
+
+    private _value: any = null;
+    get value(): any { return this._value; }
+    set value(newVal: any) {
+        if (newVal != this._value) {
+            this._value = newVal;
+            if (this.isClean)
+                this.dirty();
+        }
+    }
+
+
+    private _tagId: number = null;
+    get tagId(): number { return this._tagId; }
+    set tagId(value: number) {
+        if (value !== this._tagId) {
+            this._tagId = value;
+            if (value !== this.tag?.id)
+                this._tag = null;
+            if (this.isClean)
+                this.dirty();
+        }
+    }
+
+    private _tag: Tag = null;
+    get tag(): Tag { return this._tag; }
+    set tag(value: Tag) {
+        this._tag = value;
+        this.tagId = value?.id ?? null;
+    }
+
+
+    duplicate(): NoteAttr {
+        const output = new NoteAttr();
+        output.noteId = this.noteId;
+        output.note = this.note;
+        output.attrId = this.attrId;
+        output.attr = this.attr;
+        output.tagId = this.tagId;
+        output.tag = this.tag;
+        output.value = this.value;
+        return output;
+    }
+
+
+    validate(throwError: boolean = false): boolean {
+        let output = null;
+
+        if (this.noteId <= 0 && !this.isNew)
+            output = 'NoteAttr noteId must be greater than zero';
+        else if (this.attrId <= 0)
+            output = 'NoteAttr attrId must be greater than zero';
+
+        if (throwError && output != null)
+            throw Error(output);
+        return output == null;
+    }
+}

package/src/models/NoteTag.test.ts

@@ -2,6 +2,7 @@ import { expect, test } from 'vitest';
 import NoteTag from './NoteTag';
 import Note from './Note';
 import Tag from './Tag';
+import Attr from './Attr';
 
 
 test('Gets initiated as new', () => {
@@ -197,4 +198,48 @@ test('validate succeeds if noteId & tagId are both positive, different values',
     nt.noteId = 123;
     nt.tagId = 234;
     expect(nt.validate()).toBe(true);
+});
+
+
+test('addAttr adds NoteAttr object to parent note', () => {
+    const note = new Note();
+    const tag = new Tag('hello').clean();
+    tag.id = 123;
+    const attr = new Attr().clean();
+    attr.id = 234;
+    const nt = note.addTag(tag);
+
+    nt.addAttr(attr);
+
+    expect(note.attrs.length).toBe(1);
+    expect(note.attrs[0].note).toBe(note);
+    expect(note.attrs[0].attr).toBe(attr);
+    expect(note.attrs[0].tag).toBe(tag);
+});
+
+test('addAttr throws error if note property not set', () => {
+    const nt = new NoteTag();
+    nt.noteId = 123;
+    nt.tag = new Tag('hello');
+    nt.tag.id = 234;
+    const attr = new Attr().clean();
+    attr.id = 345;
+    
+    expect(() => nt.addAttr(attr)).toThrowError();
+});
+
+test('attrs returns NoteAttr objects with matching tagId', () => {
+    const note = new Note();
+    const tag = new Tag('hello').clean();
+    tag.id = 123;
+    const attr1 = new Attr().clean();
+    attr1.id = 234;
+    const attr2 = new Attr().clean();
+    attr2.id = 345;
+    const nt = note.addTag(tag);
+    nt.addAttr(attr1);
+    note.addAttr(attr2);
+
+    expect(nt.attrs.length).toBe(1);
+    expect(nt.attrs[0].attr).toBe(attr1);
 });

package/src/models/NoteTag.ts

@@ -3,6 +3,8 @@
 import Note from './Note';
 import ModelWithState from './ModelWithState';
 import Tag from './Tag';
+import Attr from './Attr';
+import NoteAttr from './NoteAttr';
 
 
 export default class NoteTag extends ModelWithState<NoteTag> {
@@ -46,6 +48,19 @@ export default class NoteTag extends ModelWithState<NoteTag> {
     }
 
 
+    get attrs(): Array<NoteAttr> {
+        return this.note.attrs.filter(x => x.tagId == this.tagId);
+    }
+
+    addAttr(attr: Attr): NoteAttr {
+        if (!this.note)
+            throw new Error('Cannot call addAttr on NoteTag where note property has not been set');
+        const na = this.note.addAttr(attr);
+        na.tag = this.tag;
+        return na;
+    }
+
+
     duplicate(): NoteTag {
         const output = new NoteTag();
         output.noteId = this.noteId;

package/src/models/Tag.test.ts

@@ -50,6 +50,26 @@ test('Tag can be initiated with name in constructor', () => {
     expect(tag.name).toBe('hello');
 });
 
+
+test('Set color marks tag as dirty if currently clean', () => {
+    const tag = new Tag().clean();
+    tag.color = '112233';
+    expect(tag.isDirty).toBe(true);
+});
+
+test('Set color doesnt change tag state if new', () => {
+    const tag = new Tag().new();
+    tag.color = '112233';
+    expect(tag.isNew).toBe(true);
+});
+
+test('Set color doesnt change tag state if value not different', () => {
+    const tag = new Tag().clean();
+    tag.color = null;
+    expect(tag.isClean).toBe(true);
+});
+
+
 test('can duplicate itself', () => {
     const tag = new Tag('hello');
     const copy = tag.duplicate();
@@ -68,4 +88,46 @@ test('validate throws error if arg set to true', () => {
     const model = new Tag().clean();
     model.id = 0;
     expect(() => model.validate(true)).toThrowError();
+});
+
+test('validate prevents empty name', () => {
+    const model = new Tag();
+    model.name = null;
+    expect(model.validate()).toBe(false);
+});
+
+test('validate accepts name with letters, numbers and spaces', () => {
+    const model = new Tag();
+    model.name = 'My Tag 1';
+    expect(model.validate()).toBe(true);
+});
+
+test('validate prevents name with special characters', () => {
+    const model = new Tag();
+    model.name = 'Hello$';
+    expect(model.validate()).toBe(false);
+});
+
+test('validate prevents name starting with number', () => {
+    const model = new Tag();
+    model.name = '1he';
+    expect(model.validate()).toBe(false);
+});
+
+test('validate allows null color value', () => {
+    const model = new Tag('hello');
+    model.color = null;
+    expect(model.validate()).toBe(true);
+});
+
+test('validate allows valid color value', () => {
+    const model = new Tag('hello');
+    model.color = '#a1B2F7';
+    expect(model.validate()).toBe(true);
+});
+
+test('validate throws error if color is not valid hex', () => {
+    const model = new Tag('hello');
+    model.color = 'A9C10G8';
+    expect(model.validate()).toBe(false);
 });

package/src/models/Tag.ts

@@ -26,6 +26,17 @@ export default class Tag extends ModelWithState<Tag> {
     }
 
 
+    private _color: string = null;
+    get color(): string { return this._color; }
+    set color(value: string) {
+        if (value !== this._color) {
+            this._color = value;
+            if (this.isClean)
+                this.dirty();
+        }
+    }
+
+
     constructor(name: string = '') {
         super();
         this._name = name;
@@ -46,6 +57,10 @@ export default class Tag extends ModelWithState<Tag> {
 
         if (!this.isNew && this.id <= 0)
             output = 'Tag id must be greater than zero if in non-new state.';
+        else if (!this.name || !/^[a-zA-Z][a-zA-Z0-9 ]*[a-zA-Z0-9]?$/.test(this.name))
+            output = 'Tag name is invalid, must only contain letters, numbers, and spaces, starting with a letter';
+        else if (!!this.color && !/^#?[A-z0-9]{6}$/.test(this.color))
+            output = 'Tag color is invalid, must be a 6 character hexadecimal.';
 
         if (throwError && output != null)
             throw Error(output);