notu 0.2.1 → 0.2.2

package/src/services/QueryParser.test.ts

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

@@ -1,137 +0,0 @@
-'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;
-}

package/tsconfig.json

@@ -1,23 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2020",
-    "useDefineForClassFields": true,
-    "module": "ESNext",
-    "lib": ["ES2020", "DOM", "DOM.Iterable"],
-    "skipLibCheck": true,
-
-    /* Bundler mode */
-    "moduleResolution": "bundler",
-    "allowImportingTsExtensions": true,
-    "resolveJsonModule": true,
-    "isolatedModules": true,
-    "noEmit": true,
-
-    /* Linting */
-    "strict": false,
-    "noUnusedLocals": true,
-    "noUnusedParameters": false,
-    "noFallthroughCasesInSwitch": true
-  },
-  "include": ["src"]
-}

package/vite.config.ts

@@ -1,10 +0,0 @@
-import { defineConfig } from 'vite';
-
-export default defineConfig({
-    build: {
-        lib: {
-            name: 'notu',
-            entry: './src/index.ts'
-        }
-    }
-});