feat: allow setting show to none to hide all metadata

Author: jamiebrynes7

plugin/src/query/parser.test.ts

@@ -99,6 +99,14 @@ describe("parseQuery - rejections", () => {
         show: ["foo", "bar"],
       },
     },
+    {
+      description: "show must be 'none' literal",
+      input: {
+        name: "foo",
+        filter: "bar",
+        show: "nonee",
+      },
+    },
   ];
 
   for (const tc of testcases) {
@@ -200,6 +208,17 @@ describe("parseQuery", () => {
         show: new Set([ShowMetadataVariant.Due, ShowMetadataVariant.Project]),
       }),
     },
+    {
+      description: "with show = none",
+      input: {
+        filter: "bar",
+        show: "none",
+      },
+      expectedOutput: makeQuery({
+        filter: "bar",
+        show: new Set(),
+      }),
+    },
   ];
 
   for (const tc of testcases) {

plugin/src/query/parser.ts

@@ -3,11 +3,13 @@ import { GroupVariant, type Query, ShowMetadataVariant, SortingVariant } from "@
 import YAML from "yaml";
 import { z } from "zod";
 
+type ErrorTree = string | { msg: string; children: ErrorTree[] };
+
 export class ParsingError extends Error {
-  messages: string[];
+  messages: ErrorTree[];
   inner: unknown | undefined;
 
-  constructor(msgs: string[], inner: unknown | undefined = undefined) {
+  constructor(msgs: ErrorTree[], inner: unknown | undefined = undefined) {
     super(msgs.join("\n"));
     this.inner = inner;
     this.messages = msgs;
@@ -123,7 +125,7 @@ const querySchema = z.object({
     .optional()
     .transform((val) => val ?? defaults.sorting),
   show: z
-    .array(showSchema)
+    .union([z.array(showSchema), z.literal("none").transform(() => [])])
     .optional()
     .transform((val) => val ?? defaults.show),
   groupBy: groupBySchema.optional().transform((val) => val ?? defaults.groupBy),
@@ -159,16 +161,27 @@ function parseObjectZod(query: Record<string, unknown>): [Query, QueryWarning[]]
   ];
 }
 
-function formatZodError(error: z.ZodError): string[] {
+function formatZodError(error: z.ZodError): ErrorTree[] {
   return error.errors.map((err) => {
-    const field = err.path[0];
+    const field = formatPath(err.path);
     switch (err.code) {
       case "invalid_type":
         return `Field '${field}' is ${err.received === "undefined" ? "required" : `must be a ${err.expected}`}`;
       case "invalid_enum_value":
         return `Field '${field}' has invalid value '${err.received}'. Valid options are: ${err.options?.join(", ")}`;
+      case "invalid_union":
+        return {
+          msg: "One of the following rules must be met:",
+          children: err.unionErrors.flatMap(formatZodError),
+        };
+      case "invalid_literal":
+        return `Field '${field}' has invalid value '${err.received}', must be exactly '${err.expected}'`;
       default:
         return `Field '${field}': ${err.message}`;
     }
   });
 }
+
+function formatPath(path: (string | number)[]): string {
+  return path.map((p) => (typeof p === "number" ? `[${p}]` : p)).join(".");
+}

plugin/src/ui/components/callout/index.tsx

@@ -3,11 +3,28 @@ import classNames from "classnames";
 import type React from "react";
 import "./styles.scss";
 
+export type Contents = string | { msg: string; children: Contents[] };
+
 type Props = {
   title: string;
   className: string;
   iconId: string;
-  contents?: string[];
+  contents?: Contents[];
+};
+
+const renderContents = (content: Contents): React.ReactNode => {
+  if (typeof content === "string") {
+    return <li key={content}>{content}</li>;
+  }
+
+  return (
+    <li key={content.msg}>
+      {content.msg}
+      {content.children && content.children.length > 0 && (
+        <ul>{content.children.map((child) => renderContents(child))}</ul>
+      )}
+    </li>
+  );
 };
 
 export const Callout: React.FC<Props> = ({ title, contents, iconId, className }) => {
@@ -18,11 +35,7 @@ export const Callout: React.FC<Props> = ({ title, contents, iconId, className })
         <span>{title}</span>
       </div>
       {contents && (
-        <ul className="callout-contents">
-          {contents.map((content) => (
-            <li key={content}>{content}</li>
-          ))}
-        </ul>
+        <ul className="callout-contents">{contents.map((content) => renderContents(content))}</ul>
       )}
     </div>
   );

plugin/src/ui/query/QueryError.tsx

@@ -1,8 +1,10 @@
 import { t } from "@/i18n";
 import { ParsingError } from "@/query/parser";
-import { Callout } from "@/ui/components/callout";
+import { Callout, type Contents } from "@/ui/components/callout";
 import type React from "react";
 
+type ErrorTree = string | { msg: string; children: ErrorTree[] };
+
 type Props = {
   error: unknown;
 };
@@ -20,7 +22,7 @@ export const QueryError: React.FC<Props> = ({ error }) => {
   );
 };
 
-const getErrorMessages = (error: unknown): string[] | undefined => {
+const getErrorMessages = (error: unknown): Contents[] | undefined => {
   if (error instanceof ParsingError) {
     return error.messages;
   }