notu 0.1.0 → 0.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "notu",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "type": "module",
   "repository": {
     "type": "git",
@@ -17,5 +17,8 @@
     "typescript": "^5.0.2",
     "vite": "^4.4.5",
     "vitest": "^0.34.4"
+  },
+  "dependencies": {
+    "axios": "^1.5.1"
   }
 }

package/src/Environment.test.ts

@@ -0,0 +1,76 @@
+import { expect, test } from 'vitest';
+import Environment from './Environment';
+import { NotuClient, NotuLoginResult } from './services/HttpClient';
+import Space from './models/Space';
+import { Note } from '.';
+
+
+class TestClient implements NotuClient {
+    login(username: string, password: string): Promise<NotuLoginResult> {
+        return Promise.resolve({ success: true, error: null, token: 'qwer.asdf.zxcv' });
+    }
+
+    getSpaces(): Promise<Array<Space>> {
+        const output = [
+            new Space('Space 1'),
+            new Space('Space 2')
+        ];
+        output[0].id = 1;
+        output[1].id = 2;
+        for (const space of output)
+            space.clean();
+        return Promise.resolve(output);
+    }
+
+    saveSpace(space: Space): Promise<Space> {
+        return Promise.resolve(space.duplicate());
+    }
+
+    getNotes(query: string, spaceId: number): Promise<Array<Note>> {
+        const output = [
+            new Note(),
+            new Note(),
+            new Note()
+        ];
+        for (let i = 0; i < output.length; i++) {
+            output[i].text = 'Note ' + (i+1);
+            output[i].id = i+1;
+            output[i].spaceId = (i % 2) + 1;
+            output[i].clean();
+        }
+        return Promise.resolve(output);
+    }
+
+    getNoteCount(query: string, spaceId: number): Promise<number> {
+        return Promise.resolve(3);
+    }
+
+    saveNotes(notes: Array<Note>): Promise<Array<Note>> {
+        return Promise.resolve(notes.map(n => n.duplicate()));
+    }
+
+    customJob(name: string, data: any): Promise<any> {
+        return Promise.resolve({ test: 123 });
+    }
+}
+
+
+test('constructor takes client parameter', () => {
+    const client = new TestClient();
+    const env = new Environment(client);
+
+    expect(env.client).toBe(client);
+});
+
+test('constructor throws error if client not set', () => {
+    expect(() => new Environment(null)).toThrowError();
+});
+
+
+test('loadSpaces stores the list of spaces on the environment', async () => {
+    const env = new Environment(new TestClient());
+
+    await env.loadSpaces();
+
+    expect(env.spaces.length).toBe(2);
+});

package/src/Environment.ts

@@ -0,0 +1,51 @@
+'use strict';
+
+import { Note } from '.';
+import Space from './models/Space';
+import { NotuClient } from './services/HttpClient';
+
+
+export default class Environment {
+
+    private _client: NotuClient = null;
+    get client(): NotuClient { return this._client; }
+
+    private _spaces: Array<Space> = [];
+    get spaces(): Array<Space> { return this._spaces; }
+
+    constructor(client: NotuClient) {
+        if (!client)
+            throw Error('Client must be set on Environment constructor');
+        this._client = client;
+    }
+
+    async loadSpaces(): Promise<Array<Space>> {
+        this._spaces = await this.client.getSpaces();
+        return this.spaces;
+    }
+
+    async saveSpace(space: Space): Promise<Space> {
+        return await this.client.saveSpace(space);
+    }
+
+    async getNotes(query: string, spaceId: number): Promise<Array<Note>> {
+        return await this.client.getNotes(query, spaceId);
+    }
+
+    async getNoteCount(query: string, spaceId: number): Promise<number> {
+        return await this.client.getNoteCount(query, spaceId);
+    }
+
+    async saveNote(note: Note): Promise<Note> {
+        return (await this.client.saveNotes([note]))[0];
+    }
+
+    async saveNotes(notes: Array<Note>): Promise<Array<Note>> {
+        return await this.client.saveNotes(notes);
+    }
+
+    async customJob(name: string, data: any): Promise<any> {
+        return await this.client.customJob(name, data);
+    }
+
+}

package/src/index.ts

@@ -1,5 +1,21 @@
+import Attr from './models/Attr';
+import Environment from './Environment';
+import HttpClient from './services/HttpClient';
 import Note from './models/Note';
+import NoteAttr from './models/NoteAttr';
+import NoteTag from './models/NoteTag';
+import parseQuery from './services/QueryParser';
+import Space from './models/Space';
+import Tag from './models/Tag';
 
 export {
-    Note
+    Attr,
+    Environment,
+    HttpClient,
+    Note,
+    NoteAttr,
+    NoteTag,
+    parseQuery,
+    Space,
+    Tag
 };

package/src/models/Attr.test.ts

@@ -190,4 +190,25 @@ test('validate throws error if arg set to true', () => {
     const model = new Attr();
     model.spaceId = 0;
     expect(() => model.validate(true)).toThrowError();
+});
+
+
+test('defaultValue returns correct value for text', () => {
+    const model = new Attr().asText();
+    expect(model.defaultValue).toBe('');
+});
+
+test('defaultValue returns correct value for number', () => {
+    const model = new Attr().asNumber();
+    expect(model.defaultValue).toBe(0);
+});
+
+test('defaultValue returns correct value for boolean', () => {
+    const model = new Attr().asBoolean();
+    expect(model.defaultValue).toBe(false);
+});
+
+test('defaultValue returns correct value for date', () => {
+    const model = new Attr().asDate();
+    expect(model.defaultValue.getSeconds()).toBe(new Date().getSeconds());
 });

package/src/models/Attr.ts

@@ -108,4 +108,18 @@ export default class Attr extends ModelWithState<Attr> {
 
         return output == null;
     }
+
+
+    get defaultValue(): any {
+        switch (this.type) {
+            case 'TEXT':
+                return '';
+            case 'NUMBER':
+                return 0;
+            case 'BOOLEAN':
+                return false;
+            case 'DATE':
+                return new Date();
+        }
+    }
 }

package/src/models/Note.test.ts

@@ -2,6 +2,7 @@ import { expect, test } from 'vitest';
 import Note from './Note';
 import Tag from './Tag';
 import Space from './Space';
+import Attr from './Attr';
 
 
 function newCleanTag(): Tag {
@@ -11,6 +12,13 @@ function newCleanTag(): Tag {
     return tag;
 }
 
+function newCleanAttr(): Attr {
+    const attr = new Attr();
+    attr.id = 234;
+    attr.clean();
+    return attr;
+}
+
 
 test('gets initiated with sensible defaults', () => {
     const note = new Note();
@@ -245,6 +253,15 @@ test('validate calls validate on each added tag', () => {
     expect(note.validate()).toBe(false);
 });
 
+test('validate calls validate on each added attr', () => {
+    const note = new Note();
+    note.spaceId = 123;
+    const na = note.addAttr(newCleanAttr());
+    expect(note.validate()).toBe(true);
+    na.attrId = 0;
+    expect(note.validate()).toBe(false);
+});
+
 
 test('addTag adds new NoteTag object', () => {
     const tag = newCleanTag();
@@ -319,4 +336,72 @@ test('removeTag marks existing tag on note as deleted', () => {
 
     expect(note.tags.length).toBe(1);
     expect(note.tags[0].isDeleted).toBe(true);
+});
+
+
+test('addAttr adds new NoteAttr object', () => {
+    const attr = newCleanAttr();
+    const note = new Note();
+
+    note.addAttr(attr);
+    
+    expect(note.attrs.length).toBe(1);
+    expect(note.attrs[0].note).toBe(note);
+    expect(note.attrs[0].attr).toBe(attr);
+});
+
+test('addAttr returns existing NoteAttr object if trying to add duplicate attr', () => {
+    const attr = newCleanAttr();
+    const note = new Note();
+    note.addAttr(attr);
+
+    note.addAttr(attr);
+
+    expect(note.attrs.length).toBe(1);
+    expect(note.attrs[0].note).toBe(note);
+    expect(note.attrs[0].attr).toBe(attr);
+});
+
+test('addAttr undeletes existing NoteAttr if trying to add duplicate tag', () => {
+    const attr = newCleanAttr();
+    const note = new Note();
+    const na = note.addAttr(attr);
+    na.delete();
+
+    note.addAttr(attr);
+
+    expect(note.attrs.length).toBe(1);
+    expect(na.isDirty).toBe(true);
+});
+
+test('addAttr throws error if trying to add deleted attr', () => {
+    const attr = newCleanAttr().delete();
+    const note = new Note();
+    expect(() => note.addAttr(attr)).toThrowError();
+});
+
+test('addAttr prevents note from adding attr that hasnt been saved yet', () => {
+    const note = new Note();
+    expect(() => note.addAttr(new Attr())).toThrowError();
+});
+
+test('removeAttr removes newly added attr from note', () => {
+    const attr = newCleanAttr();
+    const note = new Note();
+    note.addAttr(attr);
+
+    note.removeAttr(attr);
+
+    expect(note.attrs.length).toBe(0);
+});
+
+test('removeAttr marks existing attr on note as deleted', () => {
+    const attr = newCleanAttr();
+    const note = new Note();
+    note.addAttr(attr).clean();
+
+    note.removeAttr(attr);
+
+    expect(note.attrs.length).toBe(1);
+    expect(note.attrs[0].isDeleted).toBe(true);
 });

package/src/models/Note.ts

@@ -1,9 +1,11 @@
 'use strict';
 
 import ModelWithState from './ModelWithState';
+import NoteAttr from './NoteAttr';
 import NoteTag from './NoteTag';
 import Space from './Space';
 import Tag from './Tag';
+import Attr from './Attr';
 
 
 export default class Note extends ModelWithState<Note> {
@@ -129,6 +131,40 @@ export default class Note extends ModelWithState<Note> {
     }
 
 
+    private _attrs: Array<NoteAttr> = [];
+    get attrs(): Array<NoteAttr> { return this._attrs; }
+
+    addAttr(attr: Attr): NoteAttr {
+        if (attr.isDeleted)
+            throw Error('Cannot add an attribute marked as deleted to a note');
+        if (attr.isNew)
+            throw Error('Cannot add an attribute that hasn\'t yet been saved to a note');
+        let na = this.attrs.find(x => x.attrId == attr.id);
+        if (!!na) {
+            if (na.isDeleted)
+                na.dirty();
+            return na;
+        }
+        na = new NoteAttr();
+        na.note = this;
+        na.attr = attr;
+        this._attrs.push(na);
+        return na;
+    }
+
+    removeAttr(attr: Attr): Note {
+        const na = this.attrs.find(x => x.attrId == attr.id);
+        if (!na)
+            return this;
+
+        if (na.isNew)
+            this._attrs = this._attrs.filter(x => x !== na);
+        else
+            na.delete();
+        return this;
+    }
+
+
     duplicate(): Note {
         const output = new Note();
         output.id = this.id;
@@ -158,6 +194,10 @@ export default class Note extends ModelWithState<Note> {
             if (!nt.validate(throwError))
                 return false;
         }
+        for (const na of this.attrs) {
+            if (!na.validate(throwError))
+                return false;
+        }
 
         return output == null;
     }