notu 0.1.0

package/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "notu",
+  "version": "0.1.0",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/jamescoyle1989/notu.git"
+  },
+  "author": "James Coyle",
+  "license": "MIT",
+  "scripts": {
+    "test": "vitest",
+    "build": "tsc && vite build",
+    "publish": "tsc && vite build && npm publish"
+  },
+  "devDependencies": {
+    "typescript": "^5.0.2",
+    "vite": "^4.4.5",
+    "vitest": "^0.34.4"
+  }
+}

package/src/index.ts

@@ -0,0 +1,5 @@
+import Note from './models/Note';
+
+export {
+    Note
+};

package/src/models/Attr.test.ts

@@ -0,0 +1,193 @@
+import { expect, test } from 'vitest';
+import Attr from './Attr';
+import Space from './Space';
+
+
+test('Gets initiated as new', () => {
+    const attr = new Attr();
+    expect(attr.isNew).toBe(true);
+});
+
+
+test('Set name marks attr as dirty if currently clean', () => {
+    const attr = new Attr().clean();
+    attr.name = 'asdf';
+    expect(attr.isDirty).toBe(true);
+});
+
+test('Set name doesnt change attr state if new', () => {
+    const attr = new Attr().new();
+    attr.name = 'asdf';
+    expect(attr.isNew).toBe(true);
+});
+
+test('Set name doesnt change attr state if value not different', () => {
+    const attr = new Attr().clean();
+    attr.name = '';
+    expect(attr.isClean).toBe(true);
+});
+
+
+test('Set type is allowed if attr is new', () => {
+    const attr = new Attr().new();
+    attr.type = 'BOOLEAN';
+    expect(attr.type).toBe('BOOLEAN');
+});
+
+test('Set type is not allowed if attr is not new', () => {
+    const attr = new Attr().clean();
+    expect(() => attr.type = 'BOOLEAN').toThrowError();
+});
+
+test('isText returns true if type is text', () => {
+    const attr = new Attr();
+    attr.type = 'TEXT';
+    expect(attr.isText).toBe(true);
+    attr.type = 'NUMBER';
+    expect(attr.isText).toBe(false);
+});
+
+test('isNumber returns true if type is number', () => {
+    const attr = new Attr();
+    attr.type = 'TEXT';
+    expect(attr.isNumber).toBe(false);
+    attr.type = 'NUMBER';
+    expect(attr.isNumber).toBe(true);
+});
+
+test('isBoolean returns true if type is boolean', () => {
+    const attr = new Attr();
+    attr.type = 'TEXT';
+    expect(attr.isBoolean).toBe(false);
+    attr.type = 'BOOLEAN';
+    expect(attr.isBoolean).toBe(true);
+});
+
+test('isDate returns true if type is date', () => {
+    const attr = new Attr();
+    attr.type = 'TEXT';
+    expect(attr.isDate).toBe(false);
+    attr.type = 'DATE';
+    expect(attr.isDate).toBe(true);
+});
+
+test('asText sets type', () => {
+    const attr = new Attr().asText();
+    expect(attr.type).toBe('TEXT');
+});
+
+test('asNumber sets type', () => {
+    const attr = new Attr().asNumber();
+    expect(attr.type).toBe('NUMBER');
+});
+
+test('asBoolean sets type', () => {
+    const attr = new Attr().asBoolean();
+    expect(attr.type).toBe('BOOLEAN');
+});
+
+test('asDate sets type', () => {
+    const attr = new Attr().asDate();
+    expect(attr.type).toBe('DATE');
+});
+
+
+test('Set spaceId marks attr as dirty if currently clean', () => {
+    const attr = new Attr().clean();
+    attr.spaceId = 123;
+    expect(attr.isDirty).toBe(true);
+});
+
+test('Set spaceId doesnt change attr state if new', () => {
+    const attr = new Attr().new();
+    attr.spaceId = 123;
+    expect(attr.isNew).toBe(true);
+});
+
+test('Set spaceId doesnt change attr state if value not different', () => {
+    const attr = new Attr().clean();
+    attr.spaceId = attr.spaceId;
+    expect(attr.isClean).toBe(true);
+});
+
+test('Setting space with id different than current spaceId updates state', () => {
+    const attr = new Attr();
+    attr.spaceId = 57;
+    attr.clean();
+    const space = new Space('hello');
+    space.id = 60;
+
+    attr.space = space;
+
+    expect(attr.spaceId).toBe(60);
+    expect(attr.isDirty).toBe(true);
+});
+
+test('Setting space with id same as current spaceId preserves state', () => {
+    const attr = new Attr();
+    attr.spaceId = 80;
+    attr.clean();
+    const space = new Space('hello');
+    space.id = 80;
+
+    attr.space = space;
+
+    expect(attr.spaceId).toBe(80);
+    expect(attr.isClean).toBe(true);
+});
+
+test('Setting spaceId to new value removes space object', () => {
+    const attr = new Attr();
+    const space = new Space('hello');
+    space.id = 80;
+    attr.space = space;
+
+    attr.spaceId = 81;
+
+    expect(attr.space).toBeNull();
+});
+
+test('Setting spaceId to same as current space id preserves it', () => {
+    const attr = new Attr();
+    const space = new Space('hello');
+    space.id = 80;
+    attr.space = space;
+    
+    attr.spaceId = 80;
+
+    expect(attr.space.name).toBe('hello');
+});
+
+
+test('Can duplicate itself', () => {
+    const attr = new Attr();
+    const space = new Space('hello');
+    space.id = 123;
+    attr.space = space;
+    const copy = attr.duplicate();
+    expect(copy.id).toBe(attr.id);
+    expect(copy.name).toBe(attr.name);
+    expect(copy.type).toBe(attr.type);
+    expect(copy.space).toBe(attr.space);
+    expect(copy.spaceId).toBe(attr.spaceId);
+});
+
+
+test('validate fails if spaceId is 0', () => {
+    const model = new Attr();
+    model.spaceId = 0;
+    expect(model.validate()).toBe(false);
+});
+
+test('validate fails if not new and id <= 0', () => {
+    const model = new Attr().clean();
+    model.id = 0;
+    model.spaceId = 123;
+    expect(model.validate()).toBe(false);
+});
+
+test('validate throws error if arg set to true', () => {
+    const model = new Attr();
+    model.spaceId = 0;
+    expect(() => model.validate(true)).toThrowError();
+});

package/src/models/Attr.ts

@@ -0,0 +1,111 @@
+'use strict';
+
+import ModelWithState from './ModelWithState';
+import Space from './Space';
+
+
+const ATTR_TYPE = {
+    TEXT: 'TEXT',
+    NUMBER: 'NUMBER',
+    BOOLEAN: 'BOOLEAN',
+    DATE: 'DATE'
+};
+
+export type AttrType = keyof typeof ATTR_TYPE;
+
+
+export default class Attr extends ModelWithState<Attr> {
+    id: number = 0;
+
+    
+    private _name: string = '';
+    get name(): string { return this._name; }
+    set name(value: string) {
+        if (value !== this._name) {
+            this._name = value;
+            if (this.isClean)
+                this.dirty();
+        }
+    }
+
+    private _type: AttrType = 'TEXT';
+    get type(): AttrType { return this._type; }
+    set type(value: AttrType) {
+        if (!this.isNew)
+            throw Error('Cannot change an attribute\'s type once it has been created.');
+        this._type = value;
+    }
+
+    get isText(): boolean { return this.type == 'TEXT'; }
+
+    get isNumber(): boolean { return this.type == 'NUMBER'; }
+
+    get isBoolean(): boolean { return this.type == 'BOOLEAN'; }
+
+    get isDate(): boolean { return this.type == 'DATE'; }
+
+    asText(): Attr {
+        this.type = 'TEXT';
+        return this;
+    }
+
+    asNumber(): Attr {
+        this.type = 'NUMBER';
+        return this;
+    }
+
+    asBoolean(): Attr {
+        this.type = 'BOOLEAN';
+        return this;
+    }
+
+    asDate(): Attr {
+        this.type = 'DATE';
+        return this;
+    }
+
+
+    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;
+    }
+
+
+    duplicate(): Attr {
+        const output = new Attr();
+        output.id = this.id;
+        output.name = this.name;
+        output.type = this.type;
+        output.space = this.space;
+        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 = 'Attr id must be greater than zero if in non-new state.';
+
+        if (throwError && output != null)
+            throw Error(output);
+
+        return output == null;
+    }
+}

package/src/models/ModelWithState.test.ts

@@ -0,0 +1,66 @@
+import { expect, test } from 'vitest';
+import ModelWithState from './ModelWithState';
+
+
+class TestModel extends ModelWithState<TestModel> {
+}
+
+
+test('state gets defaulted to new', () => {
+    const model = new ModelWithState<TestModel>();
+    expect(model.state).toBe('NEW');
+});
+
+test('clean() changes model state', () => {
+    const model = new ModelWithState<TestModel>().clean();
+    expect(model.state).toBe('CLEAN');
+});
+
+test('dirty() changes model state', () => {
+    const model = new ModelWithState<TestModel>().dirty();
+    expect(model.state).toBe('DIRTY');
+});
+
+test('delete() changes model state', () => {
+    const model = new ModelWithState<TestModel>().delete();
+    expect(model.state).toBe('DELETED');
+});
+
+test('new() changes model state', () => {
+    const model = new ModelWithState<TestModel>().dirty().new();
+    expect(model.state).toBe('NEW');
+});
+
+test('isNew returns correct value', () => {
+    const model = new ModelWithState<TestModel>().new();
+    expect(model.isNew).toBe(true);
+    model.dirty();
+    expect(model.isNew).toBe(false);
+});
+
+test('isClean returns correct value', () => {
+    const model = new ModelWithState<TestModel>().new();
+    expect(model.isClean).toBe(false);
+    model.clean();
+    expect(model.isClean).toBe(true);
+});
+
+test('isDirty returns correct value', () => {
+    const model = new ModelWithState<TestModel>().new();
+    expect(model.isDirty).toBe(false);
+    model.dirty();
+    expect(model.isDirty).toBe(true);
+});
+
+test('isDeleted returns correct value', () => {
+    const model = new ModelWithState<TestModel>().new();
+    expect(model.isDeleted).toBe(false);
+    model.delete();
+    expect(model.isDeleted).toBe(true);
+});
+
+
+test('validate does nothing', () => {
+    const model = new ModelWithState<TestModel>().new();
+    expect(model.validate()).toBe(true);
+});

package/src/models/ModelWithState.ts

@@ -0,0 +1,57 @@
+'use strict';
+
+
+const MODEL_STATE = {
+    NEW: 'NEW',
+    CLEAN: 'CLEAN',
+    DIRTY: 'DIRTY',
+    DELETED: 'DELETED'
+};
+
+export type ModelState = keyof typeof MODEL_STATE;
+
+
+export default class ModelWithState<T extends ModelWithState<T>> {
+    state: ModelState = 'NEW';
+
+    new(): T {
+        this.state = 'NEW';
+        return (this as any) as T;
+    }
+
+    clean(): T {
+        this.state = 'CLEAN';
+        return (this as any) as T;
+    }
+
+    dirty(): T {
+        this.state = 'DIRTY';
+        return (this as any) as T;
+    }
+
+    delete(): T {
+        this.state = 'DELETED';
+        return (this as any) as T;
+    }
+
+    get isNew(): boolean {
+        return this.state == 'NEW';
+    }
+
+    get isClean(): boolean {
+        return this.state == 'CLEAN';
+    }
+
+    get isDirty(): boolean {
+        return this.state == 'DIRTY';
+    }
+
+    get isDeleted(): boolean {
+        return this.state == 'DELETED';
+    }
+
+
+    validate(throwError: boolean = false): boolean {
+        return true;
+    }
+}