More linting

plugs/query/query.plug.yaml

@@ -4,6 +4,11 @@ functions:
     path: query.ts:widget
     codeWidget: query
 
+  lintQuery:
+    path: query.ts:lintQuery
+    events:
+    - editor:lint
+
   templateWidget:
     path: template.ts:widget
     codeWidget: template

plugs/query/query.ts

@@ -1,10 +1,15 @@
-import type { WidgetContent } from "$sb/app_event.ts";
-import { events, language, system } from "$sb/syscalls.ts";
-import { parseTreeToAST } from "$sb/lib/tree.ts";
+import type { LintEvent, WidgetContent } from "$sb/app_event.ts";
+import { events, language, space, system } from "$sb/syscalls.ts";
+import {
+  findNodeOfType,
+  parseTreeToAST,
+  traverseTreeAsync,
+} from "$sb/lib/tree.ts";
 import { astToKvQuery } from "$sb/lib/parse-query.ts";
 import { jsonToMDTable, renderQueryTemplate } from "../directive/util.ts";
 import { loadPageObject, replaceTemplateVars } from "../template/template.ts";
-import { resolvePath } from "$sb/lib/resolve.ts";
+import { cleanPageRef, resolvePath } from "$sb/lib/resolve.ts";
+import { LintDiagnostic } from "$sb/types.ts";
 
 export async function widget(
   bodyText: string,
@@ -73,3 +78,90 @@ export async function widget(
     );
   }
 }
+
+export async function lintQuery(
+  { name, tree }: LintEvent,
+): Promise<LintDiagnostic[]> {
+  const pageObject = await loadPageObject(name);
+  const diagnostics: LintDiagnostic[] = [];
+  await traverseTreeAsync(tree, async (node) => {
+    if (node.type === "FencedCode") {
+      const codeInfo = findNodeOfType(node, "CodeInfo")!;
+      if (!codeInfo) {
+        return true;
+      }
+      const codeLang = codeInfo.children![0].text!;
+      if (
+        codeLang !== "query"
+      ) {
+        return true;
+      }
+      const codeText = findNodeOfType(node, "CodeText");
+      if (!codeText) {
+        return true;
+      }
+      const bodyText = codeText.children![0].text!;
+      try {
+        const queryAST = parseTreeToAST(
+          await language.parseLanguage(
+            "query",
+            await replaceTemplateVars(bodyText, pageObject),
+          ),
+        );
+        const parsedQuery = astToKvQuery(queryAST[1]);
+        const allSources = await allQuerySources();
+        if (
+          parsedQuery.querySource &&
+          !allSources.includes(parsedQuery.querySource)
+        ) {
+          diagnostics.push({
+            from: codeText.from!,
+            to: codeText.to!,
+            message: `Unknown query source '${parsedQuery.querySource}'`,
+            severity: "error",
+          });
+        }
+        if (parsedQuery.render) {
+          const templatePage = resolvePath(
+            name,
+            cleanPageRef(parsedQuery.render),
+          );
+          try {
+            await space.getPageMeta(templatePage);
+          } catch (e: any) {
+            diagnostics.push({
+              from: codeText.from!,
+              to: codeText.to!,
+              message: `Could not resolve template ${templatePage}`,
+              severity: "error",
+            });
+          }
+        }
+      } catch (e: any) {
+        diagnostics.push({
+          from: codeText.from!,
+          to: codeText.to!,
+          message: e.message,
+          severity: "error",
+        });
+      }
+    }
+    return false;
+  });
+  return diagnostics;
+}
+
+async function allQuerySources(): Promise<string[]> {
+  const allEvents = await events.listEvents();
+
+  const allSources = allEvents
+    .filter((eventName) =>
+      eventName.startsWith("query:") && !eventName.includes("*")
+    )
+    .map((source) => source.substring("query:".length));
+
+  const allObjectTypes: string[] = (await events.dispatchEvent("query_", {}))
+    .flat();
+
+  return [...allSources, ...allObjectTypes];
+}