flowquery 1.0.46 → 1.0.47

package/tests/tokenization/token_mapper.test.ts

@@ -1,47 +0,0 @@
-import TokenMapper from "../../src/tokenization/token_mapper";
-import Symbol from "../../src/tokenization/symbol";
-import Keyword from "../../src/tokenization/keyword";
-import Operator from "../../src/tokenization/operator";
-
-test('mapper with Symbols', () => {
-    const mapper = new TokenMapper(Symbol);
-    expect(mapper.map(Symbol.LEFT_PARENTHESIS)).toBeDefined();
-    expect(mapper.map(Symbol.RIGHT_PARENTHESIS)).toBeDefined();
-    expect(mapper.map(Symbol.COMMA)).toBeDefined();
-    expect(mapper.map(Symbol.DOT)).toBeDefined();
-    expect(mapper.map(Symbol.COLON)).toBeDefined();
-
-    expect(mapper.map(Operator.ADD)).toBeUndefined();
-});
-
-test('mapper with Keywords', () => {
-    const mapper = new TokenMapper(Keyword);
-    expect(mapper.map(Keyword.MATCH)).toBeDefined();
-    expect(mapper.map(Keyword.RETURN)).toBeDefined();
-    expect(mapper.map(Keyword.WHERE)).toBeDefined();
-
-    expect(mapper.map('not_a_keyword')).toBeUndefined();
-});
-
-test('mapper with Operators', () => {
-    const mapper = new TokenMapper(Operator);
-    expect(mapper.map(Operator.GREATER_THAN_OR_EQUAL)).toBeDefined();
-    expect(mapper.map(Operator.ADD.valueOf())).toBeDefined();
-    expect(mapper.map(Operator.SUBTRACT)).toBeDefined();
-    expect(mapper.map(Operator.NOT)).toBeDefined();
-    expect(mapper.map(Operator.EQUALS)).toBeDefined();
-    expect(mapper.map(Operator.NOT_EQUALS)).toBeDefined();
-    expect(mapper.map(Operator.LESS_THAN)).toBeDefined();
-    expect(mapper.map(Operator.LESS_THAN_OR_EQUAL)).toBeDefined();
-
-    expect(mapper.map(Operator.GREATER_THAN_OR_EQUAL + "1")).toBeDefined();
-
-    expect(mapper.map('i_s_n_o_t_an_operator')).toBeUndefined();
-});
-
-test('mapper with mixed types', () => {
-    const mapper = new TokenMapper(Symbol);
-    expect(mapper.map(Symbol.LEFT_PARENTHESIS)).toBeDefined();
-    expect(mapper.map(Symbol.RIGHT_PARENTHESIS)).toBeDefined();
-    expect(mapper.map(Symbol.COMMA)).toBeDefined();
-});

package/tests/tokenization/tokenizer.test.ts

@@ -1,191 +0,0 @@
-import Tokenizer from "../../src/tokenization/tokenizer";
-
-test("Tokenizer.tokenize() should return an array of tokens", () => {
-    const tokenizer = new Tokenizer("MATCH (n:Person) RETURN n");
-    const tokens = tokenizer.tokenize();
-    expect(tokens).toBeDefined();
-    expect(tokens.length).toBeGreaterThan(0);
-});
-
-test("Tokenizer.tokenize() should handle escaped quotes", () => {
-    const tokenizer = new Tokenizer('return "hello \\"world"');
-    const tokens = tokenizer.tokenize();
-    expect(tokens).toBeDefined();
-    expect(tokens.length).toBeGreaterThan(0);
-});
-
-test("Test predicate function", () => {
-    const tokenizer = new Tokenizer("RETURN sum(n in [1, 2, 3] | n where n > 1)");
-    const tokens = tokenizer.tokenize();
-    expect(tokens).toBeDefined();
-    expect(tokens.length).toBeGreaterThan(0);
-});
-
-test("Test f-string", () => {
-    const tokenizer = new Tokenizer('RETURN f"hello {world}"');
-    const tokens = tokenizer.tokenize();
-    expect(tokens).toBeDefined();
-    expect(tokens.length).toBeGreaterThan(0);
-});
-
-test("Test another f-string", () => {
-    const tokenizer = new Tokenizer("RETURN f`Value is: {value}`");
-    const tokens = tokenizer.tokenize();
-    expect(tokens).toBeDefined();
-    expect(tokens.length).toBeGreaterThan(0);
-});
-
-test("Test", () => {
-    const tokenizer = new Tokenizer("WITH 1 AS n RETURN n");
-    const tokens = tokenizer.tokenize();
-    expect(tokens).toBeDefined();
-    expect(tokens.length).toBeGreaterThan(0);
-});
-
-test("Test associative array with backtick string", () => {
-    const tokenizer = new Tokenizer("RETURN {`key`: `value`}");
-    const tokens = tokenizer.tokenize();
-    expect(tokens).toBeDefined();
-    expect(tokens.length).toBeGreaterThan(0);
-});
-
-test("Test limit", () => {
-    const tokenizer = new Tokenizer("unwind range(1, 10) as n limit 5 return n");
-    const tokens = tokenizer.tokenize();
-    expect(tokens).toBeDefined();
-    expect(tokens.length).toBeGreaterThan(0);
-});
-
-test("Test return -2", () => {
-    const tokenizer = new Tokenizer("return [:-2], -2");
-    const tokens = tokenizer.tokenize();
-    expect(tokens).toBeDefined();
-    expect(tokens.length).toBeGreaterThan(0);
-});
-
-test("Test range with function", () => {
-    const tokenizer = new Tokenizer(`
-        with range(1,10) as data
-        return range(0, size(data)-1) as indices
-    `);
-    const tokens = tokenizer.tokenize();
-    expect(tokens).toBeDefined();
-    expect(tokens.length).toBeGreaterThan(0);
-});
-
-test("Test create virtual node", () => {
-    const tokenizer = new Tokenizer(`
-        CREATE VIRTUAL (:Person) AS {
-            call users() YIELD id, name
-        }
-    `);
-    const tokens = tokenizer.tokenize();
-    expect(tokens).toBeDefined();
-    expect(tokens.length).toBeGreaterThan(0);
-});
-
-test("Test create virtual relationship", () => {
-    const tokenizer = new Tokenizer(`
-        CREATE VIRTUAL (:Person)-[:KNOWS]->(:Person) AS {
-            call friendships() YIELD user1_id, user2_id
-        }
-    `);
-    const tokens = tokenizer.tokenize();
-    expect(tokens).toBeDefined();
-    expect(tokens.length).toBeGreaterThan(0);
-});
-
-test("Match based on virtual node", () => {
-    const tokenizer = new Tokenizer(`
-        MATCH (a:Person)
-        RETURN a.name
-    `);
-    const tokens = tokenizer.tokenize();
-    expect(tokens).toBeDefined();
-    expect(tokens.length).toBeGreaterThan(0);
-});
-
-test("Match based on virtual nodes and relationships", () => {
-    const tokenizer = new Tokenizer(`
-        MATCH (a:Person)-[r:KNOWS]->(b:Person)
-        RETURN a.name, b.name
-    `);
-    const tokens = tokenizer.tokenize();
-    expect(tokens).toBeDefined();
-    expect(tokens.length).toBeGreaterThan(0);
-});
-
-test("Test not equal operator", () => {
-    const tokenizer = new Tokenizer(`
-        MATCH (n:Person)
-        WHERE n.age <> 30
-        RETURN n.name AS name, n.age AS age
-    `);
-    const tokens = tokenizer.tokenize();
-    expect(tokens).toBeDefined();
-    expect(tokens.length).toBeGreaterThan(0);
-});
-
-test("Test equal operator", () => {
-    const tokenizer = new Tokenizer(`
-        MATCH (n:Person)
-        WHERE n.age = 30
-        RETURN n.name AS name, n.age AS age
-    `);
-    const tokens = tokenizer.tokenize();
-    expect(tokens).toBeDefined();
-    expect(tokens.length).toBeGreaterThan(0);
-});
-
-test("Test boolean operators", () => {
-    const tokenizer = new Tokenizer(`
-        return true AND false OR true NOT false
-    `);
-    const tokens = tokenizer.tokenize();
-    expect(tokens).toBeDefined();
-    expect(tokens.length).toBeGreaterThan(0);
-});
-
-test("Test relationship with hops", () => {
-    const tokenizer = new Tokenizer(`
-        MATCH (a:Person)-[r:KNOWS*1..3]->(b:Person)
-        RETURN a.name, b.name
-    `);
-    const tokens = tokenizer.tokenize();
-    expect(tokens).toBeDefined();
-    expect(tokens.length).toBeGreaterThan(0);
-});
-
-test("Test reserved keywords as identifiers", () => {
-    const tokenizer = new Tokenizer(`
-        WITH 1 AS return
-        RETURN return
-    `);
-    const tokens = tokenizer.tokenize();
-    expect(tokens).toBeDefined();
-    expect(tokens.length).toBeGreaterThan(0);
-});
-
-test("Test reserved keywords as part of identifiers", () => {
-    const tokenizer = new Tokenizer(`
-        unwind [
-            {from: "Alice", to: "Bob", organizer: "Charlie"},
-            {from: "Bob", to: "Charlie", organizer: "Alice"},
-            {from: "Charlie", to: "Alice", organizer: "Bob"}
-        ] as data
-        return data.from, data.to
-    `);
-    const tokens = tokenizer.tokenize();
-    expect(tokens).toBeDefined();
-    expect(tokens.length).toBeGreaterThan(0);
-});
-
-test("Test reserved keywords as relationship types and labels", () => {
-    const tokenizer = new Tokenizer(`
-        MATCH (a:RETURN)-[r:WITH]->(b:RETURN)
-        RETURN a, b
-    `);
-    const tokens = tokenizer.tokenize();
-    expect(tokens).toBeDefined();
-    expect(tokens.length).toBeGreaterThan(0);
-});

package/tests/tokenization/trie.test.ts

@@ -1,20 +0,0 @@
-import Token from "../../src/tokenization/token";
-import Keyword from "../../src/tokenization/keyword";
-import Trie from "../../src/tokenization/trie";
-
-test('Trie', () => {
-    let trie = new Trie();
-    for(const key of Object.keys(Keyword)) {
-        const token: Token | undefined = Token.method(key);
-        if(token !== undefined && token.value !== null) {
-            trie.insert(token);
-            expect(trie.find(key)).toBeDefined();
-        }
-    }
-    expect(trie.find('not_a_keyword')).toBeUndefined();
-    expect(trie.find('not_a_operator')).toBeUndefined();
-    expect(trie.find('not_a_keyword_or_operator')).toBeUndefined();
-    expect(trie.find('')).toBeUndefined();
-    expect(trie.find(' ')).toBeUndefined();
-    expect(trie.find('a')).toBeUndefined();
-});

package/tsconfig.json

@@ -1,19 +0,0 @@
-{
-  "compilerOptions": {
-    /* Visit https://aka.ms/tsconfig to read more about this file */
-    "outDir": "./dist",
-    "rootDir": "./src", // Optional, but recommended to specify the root directory
-    "target": "es2016" /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */ /* Modules */,
-    "experimentalDecorators": true /* Enable experimental support for decorators. */,
-    "module": "commonjs" /* Specify what module code is generated. */,
-    "esModuleInterop": true /* Emit additional JavaScript to ease support for importing CommonJS modules. This enables 'allowSyntheticDefaultImports' for type compatibility. */,
-    "forceConsistentCasingInFileNames": true /* Ensure that casing is correct in imports. */,
-    "strict": true,
-    "types": ["node", "jest"],
-    "sourceMap": true,
-    "declaration": true /* Generate .d.ts declaration files. */,
-    "declarationMap": true /* Generate sourcemaps for .d.ts files. */
-  },
-  "include": ["src"],
-  "exclude": ["flowquery-py", "flowquery-vscode", "docs", "misc"]
-}

package/typedoc.json

@@ -1,16 +0,0 @@
-{
-  "entryPoints": ["src/index.ts"],
-  "out": "docs/api",
-  "exclude": ["**/node_modules/**", "**/*.test.ts"],
-  "excludePrivate": true,
-  "excludeProtected": false,
-  "excludeExternals": true,
-  "readme": "README.md",
-  "name": "FlowQuery API Documentation",
-  "includeVersion": true,
-  "disableSources": false,
-  "navigation": {
-    "includeCategories": true,
-    "includeGroups": true
-  }
-}

package/vscode-settings.json.recommended

@@ -1,16 +0,0 @@
-{
-    // Recommended VS Code settings for FlowQuery development
-    // Copy this file to .vscode/settings.json to enable format-on-save
-    
-    "editor.formatOnSave": true,
-    "editor.defaultFormatter": "esbenp.prettier-vscode",
-    "[typescript]": {
-        "editor.defaultFormatter": "esbenp.prettier-vscode"
-    },
-    "[javascript]": {
-        "editor.defaultFormatter": "esbenp.prettier-vscode"
-    },
-    "[json]": {
-        "editor.defaultFormatter": "esbenp.prettier-vscode"
-    }
-}

package/webpack.config.js

@@ -1,26 +0,0 @@
-const path = require('path');
-
-module.exports = {
-    entry: './src/index.browser.ts', // Use your entry point here
-    output: {
-        filename: 'flowquery.min.js', // The output file for the browser
-        path: path.resolve(__dirname, 'dist'),
-        library: 'FlowQuery', // Expose your module as a global variable
-        libraryTarget: 'umd', // Ensure compatibility with various module systems
-        libraryExport: 'default', // Export only the default export
-    },
-    resolve: {
-        extensions: ['.ts', '.js'],
-    },
-    module: {
-        rules: [
-            {
-                test: /\.ts$/,
-                use: 'ts-loader',
-                exclude: /node_modules/,
-            },
-        ],
-    },
-    mode: 'production', // Use 'development' for unminified output
-    target: 'web', // Ensure the build is targeted for browsers
-};