@neo4j-cypher/react-codemirror 2.0.0-next.16 → 2.0.0-next.17

package/src/lang-cypher/lintWorker.ts

@@ -1,14 +1,31 @@
-import { validateSemantics } from '@neo4j-cypher/language-support';
+import {
+  DbSchema,
+  lintCypherQuery as _lintCypherQuery,
+  _internalFeatureFlags,
+} from '@neo4j-cypher/language-support';
 import workerpool from 'workerpool';
 
-workerpool.worker({ validateSemantics });
+function lintCypherQuery(
+  query: string,
+  dbSchema: DbSchema,
+  featureFlags: { consoleCommands?: boolean; cypher25?: boolean } = {},
+) {
+  // We allow to override the consoleCommands feature flag
+  if (featureFlags.consoleCommands !== undefined) {
+    _internalFeatureFlags.consoleCommands = featureFlags.consoleCommands;
+  }
+  if (featureFlags.cypher25 !== undefined) {
+    _internalFeatureFlags.cypher25 = featureFlags.cypher25;
+  }
+  return _lintCypherQuery(query, dbSchema);
+}
 
-type LinterArgs = Parameters<typeof validateSemantics>;
+workerpool.worker({ lintCypherQuery });
 
-export type LinterTask = workerpool.Promise<
-  ReturnType<typeof validateSemantics>
->;
+type LinterArgs = Parameters<typeof lintCypherQuery>;
+
+export type LinterTask = workerpool.Promise<ReturnType<typeof lintCypherQuery>>;
 
 export type LintWorker = {
-  validateSemantics: (...args: LinterArgs) => LinterTask;
+  lintCypherQuery: (...args: LinterArgs) => LinterTask;
 };

package/src/lang-cypher/syntaxValidation.ts

@@ -1,6 +1,5 @@
 import { Diagnostic, linter } from '@codemirror/lint';
 import { Extension } from '@codemirror/state';
-import { parserWrapper, validateSyntax } from '@neo4j-cypher/language-support';
 import { DiagnosticSeverity, DiagnosticTag } from 'vscode-languageserver-types';
 import workerpool from 'workerpool';
 import type { CypherConfig } from './langCypher';
@@ -16,61 +15,25 @@ const pool = workerpool.pool(WorkerURL, {
 let lastSemanticJob: LinterTask | undefined;
 
 export const cypherLinter: (config: CypherConfig) => Extension = (config) =>
-  linter((view) => {
-    if (!config.lint) {
-      return [];
-    }
-
-    const query = view.state.doc.toString();
-    const syntaxErrors = validateSyntax(query, config.schema ?? {});
-
-    return syntaxErrors.map(
-      (diagnostic): Diagnostic => ({
-        from: diagnostic.offsets.start,
-        to: diagnostic.offsets.end,
-        severity:
-          diagnostic.severity === DiagnosticSeverity.Error
-            ? 'error'
-            : 'warning',
-        message: diagnostic.message,
-      }),
-    );
-  });
-
-export const semanticAnalysisLinter: (config: CypherConfig) => Extension = (
-  config,
-) =>
   linter(async (view) => {
     if (!config.lint) {
       return [];
     }
-
     const query = view.state.doc.toString();
     if (query.length === 0) {
       return [];
     }
 
-    // we want to avoid the ANTLR4 reparse in the worker thread, this should hit our main thread cache
-    const parse = parserWrapper.parse(query);
-    const statements = parse.statementsParsing;
-
-    const anySyntacticError = statements.some(
-      (statement) => statement.syntaxErrors.length !== 0,
-    );
-
-    if (anySyntacticError) {
-      return [];
-    }
-
     try {
       if (lastSemanticJob !== undefined && !lastSemanticJob.resolved) {
         void lastSemanticJob.cancel();
       }
 
       const proxyWorker = (await pool.proxy()) as unknown as LintWorker;
-      lastSemanticJob = proxyWorker.validateSemantics(
+      lastSemanticJob = proxyWorker.lintCypherQuery(
         query,
         config.schema ?? {},
+        config.featureFlags ?? {},
       );
       const result = await lastSemanticJob;