notu 0.2.1 → 0.2.3

package/dist/index.d.ts

@@ -0,0 +1,238 @@
+import { AxiosRequestConfig } from 'axios';
+import { AxiosResponse } from 'axios';
+
+declare class Attr_2 extends ModelWithState<Attr_2> {
+    id: number;
+    private _name;
+    get name(): string;
+    set name(value: string);
+    private _type;
+    get type(): AttrType;
+    set type(value: AttrType);
+    get isText(): boolean;
+    get isNumber(): boolean;
+    get isBoolean(): boolean;
+    get isDate(): boolean;
+    asText(): Attr_2;
+    asNumber(): Attr_2;
+    asBoolean(): Attr_2;
+    asDate(): Attr_2;
+    private _spaceId;
+    get spaceId(): number;
+    set spaceId(value: number);
+    private _space;
+    get space(): Space;
+    set space(value: Space);
+    duplicate(): Attr_2;
+    validate(throwError?: boolean): boolean;
+    get defaultValue(): any;
+}
+export { Attr_2 as Attr }
+
+declare const ATTR_TYPE: {
+    TEXT: string;
+    NUMBER: string;
+    BOOLEAN: string;
+    DATE: string;
+};
+
+declare type AttrType = keyof typeof ATTR_TYPE;
+
+export declare class Environment {
+    private _client;
+    get client(): NotuClient;
+    private _spaces;
+    get spaces(): Array<Space>;
+    constructor(client: NotuClient);
+    loadSpaces(): Promise<Array<Space>>;
+    saveSpace(space: Space): Promise<Space>;
+    getNotes(query: string, spaceId: number): Promise<Array<Note>>;
+    getNoteCount(query: string, spaceId: number): Promise<number>;
+    saveNote(note: Note): Promise<Note>;
+    saveNotes(notes: Array<Note>): Promise<Array<Note>>;
+    customJob(name: string, data: any): Promise<any>;
+}
+
+export declare class HttpClient {
+    private _url;
+    get url(): string;
+    private _token;
+    get token(): string;
+    set token(value: string);
+    private _httpRequester;
+    constructor(url: string, httpRequester?: (config: AxiosRequestConfig<any>) => Promise<AxiosResponse<any, any>>);
+    login(username: string, password: string): Promise<NotuLoginResult>;
+    getSpaces(): Promise<Array<Space>>;
+    saveSpace(space: Space): Promise<Space>;
+    getNotes(query: string, spaceId: number): Promise<Array<Note>>;
+    getNoteCount(query: string, spaceId: number): Promise<number>;
+    saveNotes(notes: Array<Note>): Promise<Array<Note>>;
+    customJob(name: string, data: any): Promise<any>;
+}
+
+declare const MODEL_STATE: {
+    NEW: string;
+    CLEAN: string;
+    DIRTY: string;
+    DELETED: string;
+};
+
+declare type ModelState = keyof typeof MODEL_STATE;
+
+declare class ModelWithState<T extends ModelWithState<T>> {
+    state: ModelState;
+    new(): T;
+    clean(): T;
+    dirty(): T;
+    delete(): T;
+    get isNew(): boolean;
+    get isClean(): boolean;
+    get isDirty(): boolean;
+    get isDeleted(): boolean;
+    validate(throwError?: boolean): boolean;
+}
+
+export declare class Note extends ModelWithState<Note> {
+    id: number;
+    private _date;
+    get date(): Date;
+    set date(value: Date);
+    private _text;
+    get text(): string;
+    set text(value: string);
+    private _archived;
+    get archived(): boolean;
+    set archived(value: boolean);
+    private _spaceId;
+    get spaceId(): number;
+    set spaceId(value: number);
+    private _space;
+    get space(): Space;
+    set space(value: Space);
+    private _ownTag;
+    get ownTag(): Tag;
+    setOwnTag(tag: string | Tag): Note;
+    removeOwnTag(): Note;
+    private _tags;
+    get tags(): Array<NoteTag>;
+    addTag(tag: Tag): NoteTag;
+    removeTag(tag: Tag): Note;
+    private _attrs;
+    get attrs(): Array<NoteAttr>;
+    addAttr(attr: Attr_2): NoteAttr;
+    removeAttr(attr: Attr_2): Note;
+    duplicate(): Note;
+    validate(throwError?: boolean): boolean;
+}
+
+export declare class NoteAttr extends ModelWithState<NoteAttr> {
+    private _noteId;
+    get noteId(): number;
+    set noteId(value: number);
+    private _note;
+    get note(): Note;
+    set note(value: Note);
+    private _attrId;
+    get attrId(): number;
+    set attrId(value: number);
+    private _attr;
+    get attr(): Attr_2;
+    set attr(newAttr: Attr_2);
+    private _value;
+    get value(): any;
+    set value(newVal: any);
+    private _tagId;
+    get tagId(): number;
+    set tagId(value: number);
+    private _tag;
+    get tag(): Tag;
+    set tag(value: Tag);
+    duplicate(): NoteAttr;
+    validate(throwError?: boolean): boolean;
+}
+
+export declare class NoteTag extends ModelWithState<NoteTag> {
+    private _noteId;
+    get noteId(): number;
+    set noteId(value: number);
+    private _note;
+    get note(): Note;
+    set note(value: Note);
+    private _tagId;
+    get tagId(): number;
+    set tagId(value: number);
+    private _tag;
+    get tag(): Tag;
+    set tag(value: Tag);
+    get attrs(): Array<NoteAttr>;
+    addAttr(attr: Attr_2): NoteAttr;
+    duplicate(): NoteTag;
+    validate(throwError?: boolean): boolean;
+}
+
+declare interface NotuClient {
+    login(username: string, password: string): Promise<NotuLoginResult>;
+    getSpaces(): Promise<Array<Space>>;
+    saveSpace(space: Space): Promise<Space>;
+    getNotes(query: string, spaceId: number): Promise<Array<Note>>;
+    getNoteCount(query: string, spaceId: number): Promise<number>;
+    saveNotes(notes: Array<Note>): Promise<Array<Note>>;
+    customJob(name: string, data: any): Promise<any>;
+}
+
+declare interface NotuLoginResult {
+    success: boolean;
+    error: string;
+    token: string;
+}
+
+declare class ParsedAttr {
+    space: string;
+    name: string;
+    exists: boolean;
+    tagNameFilters: Array<ParsedTag>;
+}
+
+declare class ParsedQuery {
+    where: string;
+    order: string;
+    tags: Array<ParsedTag>;
+    attrs: Array<ParsedAttr>;
+}
+
+declare class ParsedTag {
+    space: string;
+    name: string;
+    searchDepth: number;
+    strictSearchDepth: boolean;
+    includeOwner: boolean;
+}
+
+export declare function parseQuery(query: string): ParsedQuery;
+
+export declare class Space extends ModelWithState<Space> {
+    id: number;
+    private _name;
+    get name(): string;
+    set name(value: string);
+    constructor(name?: string);
+    duplicate(): Space;
+    validate(throwError?: boolean): boolean;
+}
+
+export declare class Tag extends ModelWithState<Tag> {
+    private _id;
+    get id(): number;
+    set id(value: number);
+    private _name;
+    get name(): string;
+    set name(value: string);
+    private _color;
+    get color(): string;
+    set color(value: string);
+    constructor(name?: string);
+    duplicate(): Tag;
+    validate(throwError?: boolean): boolean;
+}
+
+export { }

package/package.json

@@ -1,9 +1,12 @@
 {
   "name": "notu",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "type": "module",
   "main": "dist/notu.js",
   "unpkg": "dist/notu.js",
+  "files": [
+    "/dist"
+  ],
   "repository": {
     "type": "git",
     "url": "https://github.com/jamescoyle1989/notu.git"
@@ -18,6 +21,7 @@
   "devDependencies": {
     "typescript": "^5.0.2",
     "vite": "^4.4.5",
+    "vite-plugin-dts": "^3.6.3",
     "vitest": "^0.34.4"
   },
   "dependencies": {

package/src/Environment.test.ts

@@ -1,76 +0,0 @@
-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

@@ -1,51 +0,0 @@
-'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,21 +0,0 @@
-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 {
-    Attr,
-    Environment,
-    HttpClient,
-    Note,
-    NoteAttr,
-    NoteTag,
-    parseQuery,
-    Space,
-    Tag
-};

package/src/models/Attr.test.ts

@@ -1,214 +0,0 @@
-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();
-});
-
-
-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());
-});