@neo4j-cypher/react-codemirror 2.0.0-next.3 → 2.0.0-next.31

package/src/e2e_tests/performance-test.spec.tsx

@@ -1,71 +0,0 @@
-import { expect, test } from '@playwright/experimental-ct-react';
-import { CypherEditor } from '../CypherEditor';
-import { CypherEditorPage } from './e2e-utils';
-import { largeQuery, mockSchema } from './mock-data';
-
-test.use({ viewport: { width: 1000, height: 500 } });
-
-test('performance test session ', async ({ mount, page }) => {
-  test.setTimeout(30 * 1000);
-  const editorPage = new CypherEditorPage(page);
-  const component = await mount(
-    <CypherEditor prompt="neo4j>" theme="dark" lint schema={mockSchema} />,
-  );
-
-  // pressSequentially is less efficient -> we want to test the performance of the editor
-  await editorPage.getEditor().pressSequentially(`
-   MATCH (n:Person) RETURN m;`);
-
-  await editorPage.checkErrorMessage('m', 'Variable `m` not defined');
-
-  // set and unset large query a few times
-  await component.update(
-    <CypherEditor value={largeQuery} schema={mockSchema} />,
-  );
-  await component.update(<CypherEditor value="" schema={mockSchema} />);
-
-  await component.update(
-    <CypherEditor value={largeQuery} schema={mockSchema} />,
-  );
-  await component.update(<CypherEditor value="" />);
-
-  await component.update(
-    <CypherEditor value={largeQuery} schema={mockSchema} />,
-  );
-  await component.update(<CypherEditor value="" schema={mockSchema} />);
-
-  await component.update(
-    <CypherEditor value={largeQuery} schema={mockSchema} />,
-  );
-  await component.update(<CypherEditor value="" schema={mockSchema} />);
-
-  await component.update(
-    <CypherEditor value={largeQuery} schema={mockSchema} />,
-  );
-
-  await editorPage.getEditor().pressSequentially(`
- MATCH (n:P`);
-
-  await expect(
-    page.locator('.cm-tooltip-autocomplete').getByText('Person'),
-  ).toBeVisible();
-
-  await page.locator('.cm-tooltip-autocomplete').getByText('Person').click();
-
-  await expect(page.locator('.cm-tooltip-autocomplete')).not.toBeVisible();
-
-  await expect(component).toContainText('MATCH (n:Person');
-
-  await editorPage.getEditor().pressSequentially(') RETRN my');
-
-  await expect(component).toContainText('MATCH (n:Person) RETRN m');
-
-  await editorPage.checkErrorMessage(
-    'RETRN',
-    'Unexpected token. Did you mean RETURN?',
-  );
-
-  await editorPage
-    .getEditor()
-    .pressSequentially('veryveryveryverylongvariable');
-});

package/src/e2e_tests/syntax-validation.spec.tsx

@@ -1,156 +0,0 @@
-import { expect, test } from '@playwright/experimental-ct-react';
-import { CypherEditor } from '../CypherEditor';
-import { CypherEditorPage } from './e2e-utils';
-
-test.use({ viewport: { width: 1000, height: 500 } });
-test('Prop lint set to false disables syntax validation', async ({
-  page,
-  mount,
-}) => {
-  const query = 'METCH (n) RETURN n';
-
-  await mount(<CypherEditor value={query} lint={false} />);
-
-  await expect(page.locator('.cm-lintRange-error').last()).not.toBeVisible({
-    timeout: 2000,
-  });
-});
-
-test.skip('Can turn linting back on', async ({ page, mount }) => {
-  const editorPage = new CypherEditorPage(page);
-  const query = 'METCH (n) RETURN n';
-
-  const component = await mount(<CypherEditor value={query} lint={false} />);
-
-  await expect(page.locator('.cm-lintRange-error').last()).not.toBeVisible({
-    timeout: 2000,
-  });
-
-  await component.update(<CypherEditor value={query} lint />);
-
-  await editorPage.getEditor().fill('METCH (n) RETURN n');
-
-  await editorPage.checkErrorMessage(
-    'METCH',
-    'Unrecognized keyword. Did you mean MATCH?',
-  );
-});
-
-test('Syntactic errors are surfaced', async ({ page, mount }) => {
-  const editorPage = new CypherEditorPage(page);
-  const query = 'METCH (n) RETURN n';
-
-  await mount(<CypherEditor value={query} />);
-
-  await editorPage.checkErrorMessage(
-    'METCH',
-    'Unrecognized keyword. Did you mean MATCH?',
-  );
-});
-
-test('Errors for undefined labels are surfaced', async ({ page, mount }) => {
-  const editorPage = new CypherEditorPage(page);
-  const query = 'MATCH (n: Person) RETURN n';
-
-  await mount(
-    <CypherEditor
-      value={query}
-      schema={{ labels: ['Movie'], relationshipTypes: [] }}
-    />,
-  );
-
-  await editorPage.checkWarningMessage(
-    'Person',
-    "Label Person is not present in the database. Make sure you didn't misspell it or that it is available when you run this statement in your application",
-  );
-});
-
-test('Errors for multiline undefined labels are highlighted correctly', async ({
-  page,
-  mount,
-}) => {
-  const editorPage = new CypherEditorPage(page);
-  const query = `MATCH (n:\`Foo
-    Bar\`) RETURN n`;
-  const expectedMsg = `Label \`Foo
-    Bar\` is not present in the database. Make sure you didn't misspell it or that it is available when you run this statement in your application`;
-
-  await mount(
-    <CypherEditor
-      value={query}
-      schema={{ labels: ['Movie'], relationshipTypes: [] }}
-    />,
-  );
-
-  await editorPage.checkWarningMessage('`Foo', expectedMsg);
-  await editorPage.checkWarningMessage('Bar`', expectedMsg);
-});
-
-test('Semantic errors are surfaced when there are no syntactic errors', async ({
-  page,
-  mount,
-}) => {
-  const editorPage = new CypherEditorPage(page);
-  const query = 'MATCH (n) RETURN m';
-
-  await mount(<CypherEditor value={query} />);
-
-  await editorPage.checkErrorMessage('m', 'Variable `m` not defined');
-});
-
-test('Semantic errors are correctly accumulated', async ({ page, mount }) => {
-  const editorPage = new CypherEditorPage(page);
-  const query = 'CALL { MATCH (n) } IN TRANSACTIONS OF -1 ROWS';
-
-  await mount(<CypherEditor value={query} />);
-
-  await editorPage.checkErrorMessage(
-    'MATCH (n)',
-    'Query cannot conclude with MATCH (must be a RETURN clause, an update clause, a unit subquery call, or a procedure call with no YIELD)',
-  );
-
-  await editorPage.checkErrorMessage(
-    '-1',
-    "Invalid input. '-1' is not a valid value. Must be a positive integer",
-  );
-});
-
-test('Multiline errors are correctly placed', async ({ page, mount }) => {
-  const editorPage = new CypherEditorPage(page);
-  const query = `CALL { 
-    MATCH (n) 
-  } IN TRANSACTIONS 
-  OF -1 ROWS`;
-
-  await mount(<CypherEditor value={query} />);
-
-  await editorPage.checkErrorMessage(
-    'MATCH (n)',
-    'Query cannot conclude with MATCH (must be a RETURN clause, an update clause, a unit subquery call, or a procedure call with no YIELD)',
-  );
-
-  await editorPage.checkErrorMessage(
-    '-1',
-    "Invalid input. '-1' is not a valid value. Must be a positive integer",
-  );
-});
-
-test('Validation errors are correctly overlapped', async ({ page, mount }) => {
-  const editorPage = new CypherEditorPage(page);
-  const query = `CALL { MATCH (n)
-    RETURN n
-  } IN TRANSACTIONS 
-  OF -1 ROWS`;
-
-  await mount(<CypherEditor value={query} />);
-
-  await editorPage.checkErrorMessage(
-    '-1',
-    'Query cannot conclude with CALL (must be a RETURN clause, an update clause, a unit subquery call, or a procedure call with no YIELD)',
-  );
-
-  await editorPage.checkErrorMessage(
-    '-1',
-    "Invalid input. '-1' is not a valid value. Must be a positive integer",
-  );
-});

package/src/lang-cypher/ParserAdapter.ts

@@ -1,92 +0,0 @@
-import { Facet } from '@codemirror/state';
-import { Input, NodeType, Parser, PartialParse, Tree } from '@lezer/common';
-import {
-  applySyntaxColouring,
-  CypherTokenType,
-  ParsedCypherToken,
-} from '@neo4j-cypher/language-support';
-import { cypherTokenTypeToNode, parserAdapterNodeSet } from './constants';
-
-const DEFAULT_NODE_GROUP_SIZE = 4;
-
-export class ParserAdapter extends Parser {
-  cypherTokenTypeToNode: Record<CypherTokenType, NodeType> & {
-    topNode: NodeType;
-  };
-
-  constructor(facet: Facet<unknown>) {
-    super();
-    this.cypherTokenTypeToNode = cypherTokenTypeToNode(facet);
-  }
-
-  private createBufferForTokens(tokens: ParsedCypherToken[]) {
-    return tokens.map((token) => {
-      const nodeTypeId = this.cypherTokenTypeToNode[token.tokenType].id;
-      const startOffset = token.position.startOffset;
-      const endOffset = token.position.startOffset + token.length;
-
-      return [nodeTypeId, startOffset, endOffset, DEFAULT_NODE_GROUP_SIZE];
-    });
-  }
-
-  private addTopNodeToBuffer(buffer: number[][], document: string) {
-    const id = this.cypherTokenTypeToNode.topNode.id;
-    const startOffset = 0;
-    const endOffset = document.length;
-    const totalBufferLength = buffer.length * DEFAULT_NODE_GROUP_SIZE;
-
-    buffer.push([
-      id,
-      startOffset,
-      endOffset,
-      totalBufferLength + DEFAULT_NODE_GROUP_SIZE,
-    ]);
-  }
-
-  private buildTree(document: string) {
-    const tokens = applySyntaxColouring(document);
-
-    if (tokens.length < 1) {
-      return Tree.build({
-        buffer: [
-          this.cypherTokenTypeToNode.topNode.id,
-          0,
-          document.length,
-          DEFAULT_NODE_GROUP_SIZE,
-        ],
-        nodeSet: parserAdapterNodeSet(this.cypherTokenTypeToNode),
-        topID: this.cypherTokenTypeToNode.topNode.id,
-      });
-    }
-
-    const buffer = this.createBufferForTokens(tokens);
-    this.addTopNodeToBuffer(buffer, document);
-
-    return Tree.build({
-      buffer: buffer.flat(),
-      nodeSet: parserAdapterNodeSet(this.cypherTokenTypeToNode),
-      topID: this.cypherTokenTypeToNode.topNode.id,
-    });
-  }
-
-  createParse(input: Input): PartialParse {
-    return this.startParse(input);
-  }
-
-  /* There are more arguments, but since we don't do any incremental parsing, they are not useful */
-  startParse(input: string | Input): PartialParse {
-    const document =
-      typeof input === 'string' ? input : input.read(0, input.length);
-
-    const tree = this.buildTree(document);
-
-    return {
-      stoppedAt: input.length,
-      parsedPos: input.length,
-      stopAt: () => {
-        return undefined;
-      },
-      advance: () => tree,
-    };
-  }
-}

package/src/lang-cypher/lang-cypher.ts

@@ -1,32 +0,0 @@
-import {
-  defineLanguageFacet,
-  Language,
-  LanguageSupport,
-} from '@codemirror/language';
-import type { DbSchema } from '@neo4j-cypher/language-support';
-import { cypherAutocomplete } from './autocomplete';
-import { ParserAdapter } from './ParserAdapter';
-import { cypherLinter } from './syntax-validation';
-
-const facet = defineLanguageFacet({
-  commentTokens: { block: { open: '/*', close: '*/' }, line: '//' },
-  closeBrackets: { brackets: ['(', '[', '{', "'", '"', '`'] },
-});
-
-const parserAdapter = new ParserAdapter(facet);
-
-const cypherLanguage = new Language(facet, parserAdapter, [], 'cypher');
-
-export type CypherConfig = {
-  lint?: boolean;
-  schema?: DbSchema;
-};
-
-export function cypher(config: CypherConfig) {
-  return new LanguageSupport(cypherLanguage, [
-    cypherLanguage.data.of({
-      autocomplete: cypherAutocomplete(config),
-    }),
-    cypherLinter(config),
-  ]);
-}

package/src/lang-cypher/syntax-validation.ts

@@ -1,24 +0,0 @@
-import { linter } from '@codemirror/lint';
-import { Extension } from '@codemirror/state';
-import { validateSyntax } from '@neo4j-cypher/language-support';
-import { DiagnosticSeverity } from 'vscode-languageserver-types';
-import type { CypherConfig } from './lang-cypher';
-
-export const cypherLinter: (config: CypherConfig) => Extension = (config) =>
-  linter((view) => {
-    if (!config.lint) {
-      return [];
-    }
-
-    return validateSyntax(view.state.doc.toString(), config.schema).map(
-      (diagnostic) => ({
-        from: diagnostic.offsets.start,
-        to: diagnostic.offsets.end,
-        severity:
-          diagnostic.severity === DiagnosticSeverity.Error
-            ? 'error'
-            : 'warning',
-        message: diagnostic.message,
-      }),
-    );
-  });