notu 0.1.0 → 0.2.1

package/src/services/HttpClient.test.ts

@@ -0,0 +1,108 @@
+import { expect, test } from 'vitest';
+import HttpClient from './HttpClient';
+import axios, { AxiosRequestConfig, AxiosResponse } from 'axios';
+import Space from '../models/Space';
+
+
+function mockAxiosResponse(status: number, data: any): AxiosResponse<any, any> {
+    const response = {
+        data,
+        status,
+        statusText: 'hello',
+        headers: null,
+        config: null
+    };
+    if (status < 200 || status >= 300) {
+        const error = new Error('Something went wrong');
+        error['response'] = response;
+        throw error;
+    }
+    return response;
+}
+
+async function mockAxios(config: AxiosRequestConfig<any>): Promise<AxiosResponse<any, any>> {
+    if (config.method == 'post' && config.url.endsWith('/login')) {
+        if (config.data.username == 'ValidUser' && config.data.password == 'ValidPassword')
+            return mockAxiosResponse(200, 'qwer.asdf.zxcv');
+        return mockAxiosResponse(401, null);
+    }
+    if (config.method == 'get' && config.url.endsWith('/spaces')) {
+        return mockAxiosResponse(200, [
+            new Space('Space 1'),
+            new Space('Space 2')
+        ]);
+    }
+    return mockAxiosResponse(404, null);
+}
+
+
+
+
+test('constructor takes api root url', () => {
+    const client = new HttpClient('https://www.test.com');
+
+    expect(client.url).toBe('https://www.test.com');
+});
+
+test('constructor throws error if url not provided', () => {
+    expect(() => new HttpClient(null)).toThrowError();
+});
+
+test('If no httpRequester method passed in, then defaults to using axios', () => {
+    const client = new HttpClient('abcd');
+    
+    expect(client['_httpRequester']).toBe(axios);
+});
+
+
+test('login asyncronously gets token from web service', async () => {
+    const client = new HttpClient('abcd', mockAxios);
+    const loginResult = await client.login('ValidUser', 'ValidPassword');
+
+    expect(loginResult.success).toBe(true);
+    expect(loginResult.error).toBeNull();
+    expect(loginResult.token).toBe('qwer.asdf.zxcv');
+});
+
+test('login fails if username and password are invalid', async () => {
+    const client = new HttpClient('abcd', mockAxios);
+    const loginResult = await client.login('InvalidUser', 'InvalidPassword');
+
+    expect(loginResult.success).toBe(false);
+    expect(loginResult.error).toBe('Invalid username & password.');
+    expect(loginResult.token).toBeNull();
+});
+
+test('login sets token on the client', async () => {
+    const client = new HttpClient('abcd', mockAxios);
+    await client.login('ValidUser', 'ValidPassword');
+
+    expect(client.token).toBe('qwer.asdf.zxcv');
+});
+
+test('Token can be manually set if already known', () => {
+    const client = new HttpClient('abcd', mockAxios);
+    client.token = 'qwer.asdf.zxcv';
+
+    expect(client.token).toBe('qwer.asdf.zxcv');
+});
+
+
+test('getSpaces makes async call to correct URL endpoint, returns space objects', async () => {
+    let request: AxiosRequestConfig<any> = null;
+    const client = new HttpClient('abcd', r => {
+        request = r;
+        return mockAxios(r);
+    });
+    client.token = 'qwer.asdf.zxcv';
+
+    const result = await client.getSpaces();
+
+    expect(request.method).toBe('get');
+    expect(request.url).toBe('abcd/spaces');
+    expect(request.data).toBeFalsy();
+    expect(request.headers.Authorization).toBe('Bearer qwer.asdf.zxcv');
+    expect(result.length).toBe(2);
+    expect(result[0].name).toBe('Space 1');
+    expect(result[1].name).toBe('Space 2');
+});

package/src/services/HttpClient.ts

@@ -0,0 +1,151 @@
+'use strict';
+
+import axios, { AxiosRequestConfig, AxiosResponse } from "axios";
+import Space from "../models/Space";
+import { Note } from "..";
+
+
+export interface NotuLoginResult {
+    success: boolean;
+    error: string;
+    token: string;
+}
+
+
+export 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>;
+}
+
+
+export default class HttpClient {
+
+    private _url: string = null;
+    get url(): string { return this._url; }
+
+    private _token: string = null;
+    get token(): string { return this._token; }
+    set token(value: string) { this._token = value; }
+
+    //Added for testing support
+    private _httpRequester: (config: AxiosRequestConfig<any>) => Promise<AxiosResponse<any, any>>;
+
+    constructor(
+        url: string,
+        httpRequester: (config: AxiosRequestConfig<any>) => Promise<AxiosResponse<any, any>> = null
+    ) {
+        if (!url)
+            throw Error('Endpoint URL must be passed in to NotuClient constructor');
+        this._url = url;
+        this._httpRequester = httpRequester ?? axios;
+    }
+
+
+    async login(username: string, password: string): Promise<NotuLoginResult> {
+        try {
+            const result = await this._httpRequester({
+                method: 'post',
+                url: (this.url + '/login').replace('//', '/'),
+                data: { username, password }
+            });
+            this._token = result.data;
+            return { success: true, error: null, token: result.data };
+        }
+        catch (ex) {
+            if (ex.response.status == 401)
+                return { success: false, error: 'Invalid username & password.', token: null };
+            throw ex;
+        }
+    }
+
+
+    async getSpaces(): Promise<Array<Space>> {
+        const result = await this._httpRequester({
+            method: 'get',
+            url: (this.url + '/spaces').replace('//', '/'),
+            headers: {
+                Authorization: 'Bearer ' + this.token
+            }
+        });
+
+        return result.data;
+    }
+
+    async saveSpace(space: Space): Promise<Space> {
+        const result = await this._httpRequester({
+            method: 'post',
+            url: (this.url + '/spaces').replace('//', '/'),
+            data: space,
+            headers: {
+                Authorization: 'Bearer ' + this.token
+            }
+        });
+
+        return result.data;
+    }
+
+
+    async getNotes(query: string, spaceId: number): Promise<Array<Note>> {
+        const result = await this._httpRequester({
+            method: 'get',
+            url: (this.url + '/notes').replace('//', '/'),
+            data: { query, spaceId },
+            headers: {
+                Authorization: 'Bearer ' + this.token
+            }
+        });
+
+        return result.data;
+    }
+
+    async getNoteCount(query: string, spaceId: number): Promise<number> {
+        const result = await this._httpRequester({
+            method: 'get',
+            url: (this.url + '/notes').replace('//', '/'),
+            data: { query, spaceId },
+            headers: {
+                Authorization: 'Bearer ' + this.token
+            }
+        });
+
+        return result.data;
+    }
+
+    async saveNotes(notes: Array<Note>): Promise<Array<Note>> {
+        const result = await this._httpRequester({
+            method: 'post',
+            url: (this.url + '/notes').replace('//', '/'),
+            data: { notes },
+            headers: {
+                Authorization: 'Bearer ' + this.token
+            }
+        });
+
+        return result.data;
+    }
+
+
+    async customJob(name: string, data: any): Promise<any> {
+        const result = await this._httpRequester({
+            method: 'post',
+            url: (this.url + 'customjob').replace('//', '/'),
+            data: { name, data },
+            headers: {
+                Authorization: 'Bearer ' + this.token
+            }
+        });
+
+        return result.data;
+    }
+}

package/src/services/QueryParser.test.ts

@@ -0,0 +1,153 @@
+import { expect, test } from 'vitest';
+import { splitQuery, identifyTags, identifyAttrs } from './QueryParser';
+
+
+test('splitQuery should split out string into where, order', () => {
+    const result = splitQuery('#Test AND #Info ORDER BY @Price DESC');
+
+    expect(result.where).toBe('#Test AND #Info');
+    expect(result.order).toBe('@Price DESC');
+});
+
+test('splitQuery should leave order null if not specified', () => {
+    const result = splitQuery('#Test AND #Info');
+
+    expect(result.where).toBe('#Test AND #Info');
+    expect(result.order).toBeNull();
+});
+
+test('splitQuery should leave where null if not specified', () => {
+    const result = splitQuery('ORDER BY @Price DESC');
+
+    expect(result.where).toBeNull();
+    expect(result.order).toBe('@Price DESC');
+});
+
+
+test('identifyTags should correctly identify multiple tags in query', () => {
+    const result = splitQuery('#Test AND ~Info OR #~Me');
+
+    result.where = identifyTags(result.where, result);
+
+    expect(result.where).toBe('{tag0} AND {tag1} OR {tag2}');
+    expect(result.tags[0].space).toBeNull();
+    expect(result.tags[0].name).toBe('Test');
+    expect(result.tags[0].includeOwner).toBe(false);
+    expect(result.tags[0].searchDepth).toBe(1);
+    expect(result.tags[0].strictSearchDepth).toBe(true);
+    expect(result.tags[1].space).toBeNull();
+    expect(result.tags[1].name).toBe('Info');
+    expect(result.tags[1].includeOwner).toBe(true);
+    expect(result.tags[1].searchDepth).toBe(0);
+    expect(result.tags[1].strictSearchDepth).toBe(true);
+    expect(result.tags[2].space).toBeNull();
+    expect(result.tags[2].name).toBe('Me');
+    expect(result.tags[2].includeOwner).toBe(true);
+    expect(result.tags[2].searchDepth).toBe(1);
+    expect(result.tags[2].strictSearchDepth).toBe(true);
+});
+
+test('identifyTags handles spaces in tag names if wrapped in brackets', () => {
+    const result = splitQuery('#[I Am Long]');
+
+    result.where = identifyTags(result.where, result);
+
+    expect(result.where).toBe('{tag0}');
+    expect(result.tags[0].space).toBeNull();
+    expect(result.tags[0].name).toBe('I Am Long');
+    expect(result.tags[0].includeOwner).toBe(false);
+    expect(result.tags[0].searchDepth).toBe(1);
+    expect(result.tags[0].strictSearchDepth).toBe(true);
+});
+
+test('identifyTags can identify tag spaces', () => {
+    const result = splitQuery('#Space1.Tag1 AND #[Space 2.Tag 2]');
+
+    result.where = identifyTags(result.where, result);
+    
+    expect(result.where).toBe('{tag0} AND {tag1}');
+    expect(result.tags[0].space).toBe('Space1');
+    expect(result.tags[0].name).toBe('Tag1');
+    expect(result.tags[0].includeOwner).toBe(false);
+    expect(result.tags[0].searchDepth).toBe(1);
+    expect(result.tags[0].strictSearchDepth).toBe(true);
+    expect(result.tags[1].space).toBe('Space 2');
+    expect(result.tags[1].name).toBe('Tag 2');
+    expect(result.tags[1].includeOwner).toBe(false);
+    expect(result.tags[1].searchDepth).toBe(1);
+    expect(result.tags[1].strictSearchDepth).toBe(true);
+});
+
+test('identifyAttrs can correctly identify multiple attrs in query', () => {
+    const result = splitQuery('@Count > 3 AND @Depth < 4');
+
+    result.where = identifyAttrs(result.where, result);
+
+    expect(result.where).toBe('{attr0} > 3 AND {attr1} < 4');
+    expect(result.attrs[0].space).toBeNull();
+    expect(result.attrs[0].name).toBe('Count');
+    expect(result.attrs[0].exists).toBe(false);
+    expect(result.attrs[1].space).toBeNull();
+    expect(result.attrs[1].name).toBe('Depth');
+    expect(result.attrs[1].exists).toBe(false);
+});
+
+test('identifyAttrs can identify space names', () => {
+    const result = splitQuery('@MySpace.Count = 123');
+    
+    result.where = identifyAttrs(result.where, result);
+
+    expect(result.where).toBe('{attr0} = 123');
+    expect(result.attrs[0].space).toBe('MySpace');
+    expect(result.attrs[0].name).toBe('Count');
+    expect(result.attrs[0].exists).toBe(false);
+});
+
+test('identifyAttrs can identify exists queries', () => {
+    const result = splitQuery('@Help.Exists()');
+
+    result.where = identifyAttrs(result.where, result);
+
+    expect(result.where).toBe('{attr0}');
+    expect(result.attrs[0].space).toBeNull();
+    expect(result.attrs[0].name).toBe('Help');
+    expect(result.attrs[0].exists).toBe(true);
+});
+
+test('identifyAttrs can identify on tag filters', () => {
+    const result = splitQuery('@Abc.On(MyTag) > 1');
+
+    result.where = identifyAttrs(result.where, result);
+
+    expect(result.where).toBe('{attr0} > 1');
+    expect(result.attrs[0].name).toBe('Abc');
+    expect(result.attrs[0].exists).toBe(false);
+    expect(result.attrs[0].tagNameFilters[0].name).toBe('MyTag');
+});
+
+test('identifyAttrs can handle attr and space names with spaces in them', () => {
+    const result = splitQuery('@[My Space.Test Test] = 123');
+
+    result.where = identifyAttrs(result.where, result);
+
+    expect(result.where).toBe('{attr0} = 123');
+    expect(result.attrs[0].space).toBe('My Space');
+    expect(result.attrs[0].name).toBe('Test Test');
+});
+
+test('identifyAttrs can support multiple pipe-separated on(tag) filters', () => {
+    const result = splitQuery('@Abc.Exists().On(Tag1|#Space2.Tag2)');
+
+    result.where = identifyAttrs(result.where, result);
+
+    expect(result.where).toBe('{attr0}');
+    expect(result.attrs[0].name).toBe('Abc');
+    expect(result.attrs[0].exists).toBe(true);
+    expect(result.attrs[0].tagNameFilters.length).toBe(2);
+    expect(result.attrs[0].tagNameFilters[0].name).toBe('Tag1');
+    expect(result.attrs[0].tagNameFilters[0].space).toBeNull();
+    expect(result.attrs[0].tagNameFilters[0].searchDepth).toBe(0);
+    expect(result.attrs[0].tagNameFilters[1].name).toBe('Tag2');
+    expect(result.attrs[0].tagNameFilters[1].space).toBe('Space2');
+    expect(result.attrs[0].tagNameFilters[1].searchDepth).toBe(1);
+});

package/src/services/QueryParser.ts

@@ -0,0 +1,137 @@
+'use strict';
+
+
+export class ParsedQuery {
+    where: string = null;
+    order: string = null;
+    tags: Array<ParsedTag> = [];
+    attrs: Array<ParsedAttr> = [];
+}
+
+class ParsedTag {
+    space: string = null;
+    name: string = null;
+    searchDepth: number = 0;
+    strictSearchDepth: boolean = true;
+    includeOwner: boolean = false;
+}
+
+class ParsedAttr {
+    space: string = null;
+    name: string = null;
+    exists: boolean = false;
+    tagNameFilters: Array<ParsedTag> = null;
+}
+
+
+export default function parseQuery(query: string): ParsedQuery {
+    const output = splitQuery(query);
+
+    output.where = identifyTags(output.where, output);
+    output.order = identifyTags(output.order, output);
+
+    output.where = identifyAttrs(output.where, output);
+    output.order = identifyAttrs(output.order, output);
+
+    return output;
+}
+
+
+export function splitQuery(query: string): ParsedQuery {
+    query = ' ' + query + ' ';
+    const output = new ParsedQuery();
+
+    const orderByIndex = query.toUpperCase().indexOf(' ORDER BY ');
+    if (orderByIndex < 0) {
+        output.where = query.trim();
+    }
+    else {
+        output.where = query.substring(0, orderByIndex).trim();
+        output.order = query.substring(orderByIndex + ' ORDER BY '.length).trim();
+    }
+    if (output.where == '')
+        output.where = null;
+    return output;
+}
+
+
+export function identifyTags(query: string, parsedQuery: ParsedQuery): string {
+    const regexes: Array<RegExp> = [
+        /(#+\??~?|~)([\w\d]+\.)?([\w\d]+)/,            //Single word tags and space names
+        /(#+\??~?|~)\[([\w\d\s]+\.)?([\w\d\s]+)\]/     //Multi-word tags and space names wrapped in []
+    ];
+    for (const regex of regexes) {
+        while (true) {
+            const match = regex.exec(query);
+            if (!match)
+                break;
+    
+            const hashPrefix = match[1];
+            const parsedTag = new ParsedTag();
+            parsedTag.space = !!match[2] ? match[2].substring(0, match[2].length - 1) : null;
+            parsedTag.name = match[3];
+            parsedTag.includeOwner = hashPrefix.includes('~');
+            parsedTag.searchDepth = (hashPrefix.match(/#/g)||[]).length;
+            parsedTag.strictSearchDepth = !hashPrefix.includes('?');
+            
+            const fullMatch = match[0];
+            const matchStart = query.indexOf(fullMatch);
+            const matchEnd = matchStart + fullMatch.length;
+            query = query.substring(0, matchStart) + `{tag${parsedQuery.tags.length}}` + query.substring(matchEnd);
+            parsedQuery.tags.push(parsedTag);
+        }
+    }
+    return query;
+}
+
+
+export function identifyAttrs(query: string, parsedQuery: ParsedQuery): string {
+    const regexes: Array<RegExp> = [
+        /@([\w\d]+\.(?!Exists\(|On\())?([\w\d]+)/,
+        /@\[([\w\d\s]+\.)?([\w\d\s]+)\]/
+    ];
+    for (const regex of regexes) {
+        while (true) {
+            //If no more matches to be found, continue to next regex test
+            const match = regex.exec(query);
+            if (!match)
+                break;
+            
+            //Build up basic properties of ParsedAttr object
+            const parsedAttr = new ParsedAttr();
+            parsedAttr.space = !!match[1] ? match[1].substring(0, match[1].length - 1) : null;
+            parsedAttr.name = match[2];
+            
+            //Record the positions of where the match starts and ends
+            const matchStart = query.indexOf(match[0]);
+            let matchEnd = matchStart + match[0].length;
+
+            //Check if there's a test for existance of the attribute on notes
+            if (query.substring(matchEnd, matchEnd + '.Exists()'.length) == '.Exists()') {
+                parsedAttr.exists = true;
+                matchEnd += '.Exists()'.length;
+            }
+
+            //Check if there's any conditions about which tags to look for the attribute on
+            if (query.substring(matchEnd, matchEnd + '.On('.length) == '.On(') {
+                let tagFilterStart = matchEnd + '.On('.length;
+                matchEnd = query.indexOf(')', tagFilterStart);
+                if (matchEnd < 0)
+                    throw Error('Unclosed bracket detected');
+                let tagNameFilters = query.substring(tagFilterStart, matchEnd).split('|');
+                const dummyParsedQuery = new ParsedQuery();
+                for (let tagNameFilter of tagNameFilters) {
+                    if (!tagNameFilter.startsWith('~'))
+                        tagNameFilter = '~' + tagNameFilter;
+                    identifyTags(tagNameFilter, dummyParsedQuery);
+                }
+                parsedAttr.tagNameFilters = dummyParsedQuery.tags;
+                matchEnd++;
+            }
+
+            query = query.substring(0, matchStart) + `{attr${parsedQuery.attrs.length}}` + query.substring(matchEnd);
+            parsedQuery.attrs.push(parsedAttr);
+        }
+    }
+    return query;
+}