zudoku 0.25.2 → 0.26.0

package/src/lib/plugins/openapi/playground/PathParams.tsx

@@ -1,11 +1,31 @@
 import { EraserIcon } from "lucide-react";
 import { Control, Controller, useFieldArray } from "react-hook-form";
+import { Card } from "zudoku/ui/Card.js";
 import { Button } from "../../../ui/Button.js";
 import { Input } from "../../../ui/Input.js";
 import { cn } from "../../../util/cn.js";
-import { ColorizedParam } from "../ColorizedParam.js";
+import { ColorizedParam, useParamColor } from "../ColorizedParam.js";
 import type { PlaygroundForm } from "./Playground.js";
 
+const PathParamLabel = ({ name }: { name: string }) => {
+  const color = useParamColor(name);
+
+  return (
+    <div className="flex items-center">
+      <div
+        className="w-2 h-2 rounded-full"
+        style={{ backgroundColor: `hsl(${color})` }}
+      />
+
+      <ColorizedParam
+        slug={name}
+        name={name}
+        className="font-mono text-xs m-2 px-1"
+      />
+    </div>
+  );
+};
+
 export const PathParams = ({
   control,
 }: {
@@ -17,72 +37,60 @@ export const PathParams = ({
   });
 
   return (
-    <table className="w-full table-auto [&_td]:border [&_td]:py-1 [&_td]:px-2">
-      <tbody>
-        {fields.map((part, i) => (
-          <tr key={part.id} className="hover:bg-accent/40">
-            <td>
-              <Controller
-                control={control}
-                name={`pathParams.${i}.value`}
-                render={({ field }) => (
-                  <div>
-                    <ColorizedParam
-                      slug={part.name}
-                      name={part.name}
-                      backgroundOpacity="25%"
-                      borderOpacity={field.value ? "100%" : "0"}
-                      className={cn(
-                        "font-mono text-xs m-2",
-                        !field.value && "opacity-60",
-                      )}
-                    />
-                    *
-                  </div>
-                )}
-              />
-            </td>
-            <td>
-              <div className="flex justify-between items-center">
-                <Controller
-                  control={control}
-                  name={`pathParams.${i}.value`}
-                  render={({ field }) => (
-                    <Input
-                      {...field}
-                      required
-                      placeholder="Enter value"
-                      className="border-0 shadow-none ring-0 font-mono text-xs"
-                    />
-                  )}
-                />
+    <Card className="rounded-lg">
+      <table className="w-full">
+        <tbody>
+          {fields.map((part, i) => (
+            <tr key={part.id} className="hover:bg-accent/40">
+              <td className="w-5/12">
                 <Controller
                   control={control}
                   name={`pathParams.${i}.value`}
-                  render={({ field }) => (
-                    <Button
-                      size="icon"
-                      type="button"
-                      variant="ghost"
-                      aria-label="Clear value"
-                      className={cn(
-                        "ms-2",
-                        field.value.length === 0
-                          ? "opacity-0 pointer-events-none"
-                          : "opacity-100",
-                      )}
-                      title="Clear value"
-                      onClick={() => field.onChange("")}
-                    >
-                      <EraserIcon size={16} />
-                    </Button>
-                  )}
+                  render={() => <PathParamLabel name={part.name} />}
                 />
-              </div>
-            </td>
-          </tr>
-        ))}
-      </tbody>
-    </table>
+              </td>
+              <td className="w-7/12">
+                <div className="flex justify-between items-center">
+                  <Controller
+                    control={control}
+                    name={`pathParams.${i}.value`}
+                    render={({ field }) => (
+                      <Input
+                        {...field}
+                        required
+                        placeholder="Enter value"
+                        className="w-full border-0 shadow-none text-xs font-mono hover:bg-accent"
+                      />
+                    )}
+                  />
+                  <Controller
+                    control={control}
+                    name={`pathParams.${i}.value`}
+                    render={({ field }) => (
+                      <Button
+                        size="icon"
+                        type="button"
+                        variant="ghost"
+                        aria-label="Clear value"
+                        className={cn(
+                          "ms-2 mr-1",
+                          field.value.length === 0
+                            ? "opacity-0 pointer-events-none"
+                            : "opacity-100",
+                        )}
+                        title="Clear value"
+                        onClick={() => field.onChange("")}
+                      >
+                        <EraserIcon size={16} />
+                      </Button>
+                    )}
+                  />
+                </div>
+              </td>
+            </tr>
+          ))}
+        </tbody>
+      </table>
+    </Card>
   );
 };

package/src/lib/plugins/openapi/playground/Playground.tsx

@@ -46,6 +46,8 @@ export type QueryParam = {
   defaultValue?: string;
   defaultActive?: boolean;
   isRequired?: boolean;
+  enum?: string[];
+  type?: string;
 };
 export type PathParam = {
   name: string;
@@ -55,9 +57,17 @@ export type PathParam = {
 
 export type PlaygroundForm = {
   body: string;
-  queryParams: Array<{ name: string; value: string; active: boolean }>;
+  queryParams: Array<{
+    name: string;
+    value: string;
+    active: boolean;
+    enum?: string[];
+  }>;
   pathParams: Array<{ name: string; value: string }>;
-  headers: Array<{ name: string; value: string }>;
+  headers: Array<{
+    name: string;
+    value: string;
+  }>;
   identity?: string;
 };
 
@@ -92,6 +102,7 @@ export const Playground = ({
           name: param.name,
           value: param.defaultValue ?? "",
           active: param.defaultActive ?? false,
+          enum: param.enum ?? [],
         })),
         pathParams: pathParams.map((param) => ({
           name: param.name,
@@ -171,17 +182,19 @@ export const Playground = ({
     const replaced = part.replace(/[:{}]/g, "");
     const value = formState.pathParams.find((p) => p.name === replaced)?.value;
 
-    const pathParamValue = value ? (
-      <ColorizedParam backgroundOpacity="25%" name={part} slug={part}>
-        {encodeURIComponent(value)}
-      </ColorizedParam>
-    ) : (
-      <span
-        className="underline decoration-wavy decoration-red-500"
-        title={`Missing value for path parameter \`${replaced}\``}
+    const pathParamValue = (
+      <ColorizedParam
+        backgroundOpacity="25%"
+        name={part}
+        slug={part}
+        title={
+          !value
+            ? `Missing value for path parameter \`${replaced}\``
+            : undefined
+        }
       >
-        {part}
-      </span>
+        {value ? encodeURIComponent(value) : part}
+      </ColorizedParam>
     );
 
     return (
@@ -240,7 +253,7 @@ export const Playground = ({
     >
       <form onSubmit={handleSubmit((data) => queryMutation.mutateAsync(data))}>
         <div className="grid grid-cols-[8fr_7fr] text-sm h-full">
-          <div className="flex flex-col gap-4 p-8 bg-muted/50 after:bg-muted-foreground/20 relative after:absolute after:w-px after:inset-0 after:left-auto">
+          <div className="flex flex-col gap-4 p-4 after:bg-muted-foreground/20 relative after:absolute after:w-px after:inset-0 after:left-auto">
             <div className="flex gap-2 items-stretch">
               <div className="flex flex-1 items-center w-full border rounded-md">
                 <div className="border-r p-2 bg-muted rounded-l-md self-stretch font-semibold font-mono">

package/src/lib/plugins/openapi/playground/QueryParams.tsx

@@ -5,9 +5,12 @@ import {
   useFieldArray,
   useFormContext,
 } from "react-hook-form";
+import { Card } from "zudoku/ui/Card.js";
+import { Checkbox } from "zudoku/ui/Checkbox.js";
 import { Button } from "../../../ui/Button.js";
 import { Input } from "../../../ui/Input.js";
 import { cn } from "../../../util/cn.js";
+import { EnumSelector } from "./EnumSelector.js";
 import { InlineInput } from "./InlineInput.js";
 import {
   NO_IDENTITY,
@@ -34,97 +37,123 @@ export const QueryParams = ({
   const hasSelectedIdentity = selectedIdentity !== NO_IDENTITY;
 
   return (
-    <div className="">
-      <table className="w-full [&_td]:border [&_td]:p-1.5 [&_td]:px-2">
+    <Card className="rounded-lg">
+      <table className="w-full">
         <tbody>
           {fields
             .filter(
               // TODO remove this hack for Accu or make it more generic
               (field) => !(hasSelectedIdentity && field.name === "apikey"),
             )
-            .map((field, i) => (
-              <tr key={field.id} className="hover:bg-accent/40">
-                <td className="text-center">
-                  <Controller
-                    control={control}
-                    name={`queryParams.${i}.active`}
-                    render={({ field }) => (
-                      <input
-                        type="checkbox"
-                        id={`queryParams.${i}.active`}
-                        checked={field.value}
-                        onChange={field.onChange}
-                      />
-                    )}
-                  />
-                </td>
-                <td>
-                  <Controller
-                    control={control}
-                    render={({ field }) => (
-                      <InlineInput asChild>
-                        <label
-                          className="flex items-center cursor-pointer"
-                          htmlFor={`queryParams.${i}.active`}
-                          title={
-                            requiredFields[i] ? "Required field" : undefined
-                          }
-                        >
-                          {field.value}
-                          {requiredFields[i] && <sup>&nbsp;*</sup>}
-                        </label>
-                      </InlineInput>
-                    )}
-                    name={`queryParams.${i}.name`}
-                  />
-                </td>
-                <td>
-                  <div className="flex justify-between items-center">
+            .map((field, i) => {
+              const currentParam = queryParams.find(
+                (param) => param.name === field.name,
+              );
+              return (
+                <tr key={field.id} className="hover:bg-accent/40">
+                  <td className="w-5/12 flex items-center ps-3">
                     <Controller
                       control={control}
+                      name={`queryParams.${i}.active`}
                       render={({ field }) => (
-                        <Input
-                          {...field}
-                          onChange={(e) => {
-                            field.onChange(e.target.value);
-                            if (e.target.value.length > 0) {
-                              form.setValue(`queryParams.${i}.active`, true);
-                            }
-                          }}
-                          placeholder="Enter value"
-                          className="w-full border-0 shadow-none text-xs font-mono"
+                        <Checkbox
+                          variant="outline"
+                          id={`queryParams.${i}.active`}
+                          checked={field.value}
+                          onCheckedChange={field.onChange}
                         />
                       )}
-                      name={`queryParams.${i}.value`}
                     />
                     <Controller
                       control={control}
                       render={({ field }) => (
-                        <Button
-                          size="icon"
-                          type="button"
-                          variant="ghost"
-                          aria-label="Clear value"
-                          className={cn(
-                            "ms-2",
-                            field.value.length === 0
-                              ? "opacity-0 pointer-events-none"
-                              : "opacity-100",
-                          )}
-                          title="Clear value"
-                          onClick={() => field.onChange("")}
-                        >
-                          <EraserIcon size={16} />
-                        </Button>
+                        <InlineInput asChild>
+                          <label
+                            className="flex items-center cursor-pointer gap-1"
+                            htmlFor={`queryParams.${i}.active`}
+                            title={
+                              requiredFields[i] ? "Required field" : undefined
+                            }
+                          >
+                            {field.value}
+                            {requiredFields[i] && <sup>&nbsp;*</sup>}
+                          </label>
+                        </InlineInput>
                       )}
-                      name={`queryParams.${i}.value`}
+                      name={`queryParams.${i}.name`}
                     />
-                  </div>
-                </td>
-              </tr>
-            ))}
+                  </td>
+                  <td className="w-7/12">
+                    <div className="flex justify-between items-center">
+                      <Controller
+                        control={control}
+                        render={({ field }) => {
+                          const hasEnum =
+                            currentParam?.enum && currentParam.enum.length > 0;
+
+                          if (!hasEnum) {
+                            return (
+                              <Input
+                                {...field}
+                                onChange={(e) => {
+                                  field.onChange(e.target.value);
+                                  if (e.target.value.length > 0) {
+                                    form.setValue(
+                                      `queryParams.${i}.active`,
+                                      true,
+                                    );
+                                  }
+                                }}
+                                placeholder="Enter value"
+                                className="w-full border-0 shadow-none text-xs font-mono hover:bg-accent"
+                              />
+                            );
+                          }
+
+                          const enumValues = currentParam.enum ?? [];
+
+                          return (
+                            <EnumSelector
+                              value={field.value}
+                              enumValues={enumValues}
+                              onChange={field.onChange}
+                              onValueSelected={() => {
+                                form.setValue(`queryParams.${i}.active`, true);
+                              }}
+                            />
+                          );
+                        }}
+                        name={`queryParams.${i}.value`}
+                      />
+                      <Controller
+                        control={control}
+                        render={({ field }) => (
+                          <Button
+                            size="icon"
+                            type="button"
+                            variant="ghost"
+                            aria-label="Clear value"
+                            className={cn(
+                              "ms-2 mr-1",
+                              field.value.length === 0
+                                ? "opacity-0 pointer-events-none"
+                                : "opacity-100",
+                            )}
+                            title="Clear value"
+                            onClick={() => field.onChange("")}
+                          >
+                            <EraserIcon size={16} />
+                          </Button>
+                        )}
+                        name={`queryParams.${i}.value`}
+                      />
+                    </div>
+                  </td>
+                </tr>
+              );
+            })}
         </tbody>
       </table>
-    </div>
+    </Card>
   );
 };

package/src/lib/plugins/openapi/schema/SchemaComponents.tsx

@@ -1,6 +1,7 @@
 import * as Collapsible from "@radix-ui/react-collapsible";
 import { ListPlusIcon, RefreshCcwDotIcon } from "lucide-react";
 import { useCallback, useState } from "react";
+import { Badge } from "zudoku/ui/Badge.js";
 import { Markdown, ProseClasses } from "../../../components/Markdown.js";
 import { CIRCULAR_REF } from "../../../oas/parser/dereference/index.js";
 import type { SchemaObject } from "../../../oas/parser/index.js";
@@ -85,7 +86,7 @@ export const SchemaPropertyItem = ({
       <div className="flex flex-col gap-1 justify-between text-sm">
         <div className="flex gap-2 items-center">
           <code>{name}</code>
-          <span className="text-muted-foreground">
+          <Badge variant="muted">
             {schema.type === "array" && schema.items.type ? (
               <span>{schema.items.type}[]</span>
             ) : Array.isArray(schema.type) ? (
@@ -93,12 +94,8 @@ export const SchemaPropertyItem = ({
             ) : (
               <span>{schema.type}</span>
             )}
-          </span>
-          {group === "optional" && (
-            <span className="py-px px-1.5 font-medium border rounded-lg">
-              optional
-            </span>
-          )}
+          </Badge>
+          {group === "optional" && <Badge variant="outline">optional</Badge>}
         </div>
 
         {schema.description && (

package/src/lib/plugins/openapi/util/generateSchemaExample.ts

@@ -5,24 +5,35 @@ export const generateSchemaExample = (
   name?: string,
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
 ): any => {
-  // Directly return the example or default if they exist
+  // Check for schema-level example first
   if (schema.example !== undefined) {
     return schema.example;
-  } else if (schema.examples) {
-    return Object.values(schema.examples)[0];
-  } else if (schema.default !== undefined) {
-    return schema.default;
   }
 
-  if (schema.properties || schema.type === "object") {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const example: any = {};
+  // Then check for schema-level examples
+  if (
+    schema.examples &&
+    typeof schema.examples === "object" &&
+    "default" in schema.examples
+  ) {
+    const defaultExample = schema.examples.default;
+    if (defaultExample !== null) {
+      return typeof defaultExample === "object" && "value" in defaultExample
+        ? defaultExample.value
+        : defaultExample;
+    }
+  }
+
+  // For object schemas with properties
+  if (schema.type === "object" && schema.properties) {
+    const example: Record<string, any> = {};
 
-    if (schema.properties) {
-      for (const [key, propSchema] of Object.entries(schema.properties)) {
+    for (const [key, propSchema] of Object.entries(schema.properties)) {
+      if (typeof propSchema === "object") {
         example[key] = generateSchemaExample(propSchema as SchemaObject, key);
       }
     }
+
     return example;
   }
 
@@ -31,7 +42,9 @@ export const generateSchemaExample = (
       return schema.items.map((itemSchema) =>
         generateSchemaExample(itemSchema as SchemaObject),
       );
-    } else if (schema.items) {
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- OpenAPI schemas don't always adhere to spec
+    if (schema.items) {
       return [generateSchemaExample(schema.items as SchemaObject)];
     }
     return [];
@@ -51,6 +64,8 @@ export const generateSchemaExample = (
       return true;
     case "null":
       return null;
+    case "object":
+      return {};
     case undefined:
     default:
       return {};

package/src/lib/ui/Badge.tsx

@@ -4,7 +4,7 @@ import * as React from "react";
 import { cn } from "../util/cn.js";
 
 const badgeVariants = cva(
-  "inline-flex items-center rounded-full border px-2.5 py-0.5 text-xs font-semibold transition-colors focus:outline-none focus:ring-2 focus:ring-ring focus:ring-offset-2",
+  "inline-flex items-center rounded-full border px-2.5 py-0.5 text-xs font-medium transition-colors focus:outline-none focus:ring-2 focus:ring-ring focus:ring-offset-2",
   {
     variants: {
       variant: {
@@ -12,6 +12,7 @@ const badgeVariants = cva(
           "border-transparent bg-primary text-primary-foreground hover:bg-primary/80",
         secondary:
           "border-transparent bg-secondary text-secondary-foreground hover:bg-secondary/80",
+        muted: "bg-muted text-muted-foreground ",
         destructive:
           "border-transparent bg-destructive text-destructive-foreground hover:bg-destructive/80",
         outline: "text-foreground",

package/src/lib/ui/Checkbox.tsx

@@ -1,19 +1,36 @@
 import * as CheckboxPrimitive from "@radix-ui/react-checkbox";
+import { cva, type VariantProps } from "class-variance-authority";
 import { Check } from "lucide-react";
 import * as React from "react";
 
 import { cn } from "../util/cn.js";
 
+const checkboxVariants = cva(
+  "peer h-4 w-4 shrink-0 rounded-sm ring-offset-background focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:cursor-not-allowed disabled:opacity-50 data-[state=checked]:text-primary",
+  {
+    variants: {
+      variant: {
+        default: "border border-primary data-[state=checked]:bg-primary",
+        outline: "border border-input data-[state=checked]:bg-accent",
+      },
+    },
+    defaultVariants: {
+      variant: "default",
+    },
+  },
+);
+
+interface CheckboxProps
+  extends React.ComponentPropsWithoutRef<typeof CheckboxPrimitive.Root>,
+    VariantProps<typeof checkboxVariants> {}
+
 const Checkbox = React.forwardRef<
   React.ElementRef<typeof CheckboxPrimitive.Root>,
-  React.ComponentPropsWithoutRef<typeof CheckboxPrimitive.Root>
->(({ className, ...props }, ref) => (
+  CheckboxProps
+>(({ className, variant, ...props }, ref) => (
   <CheckboxPrimitive.Root
     ref={ref}
-    className={cn(
-      "peer h-4 w-4 shrink-0 rounded-sm border border-primary ring-offset-background focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:cursor-not-allowed disabled:opacity-50 data-[state=checked]:bg-primary data-[state=checked]:text-primary-foreground",
-      className,
-    )}
+    className={cn(checkboxVariants({ variant, className }))}
     {...props}
   >
     <CheckboxPrimitive.Indicator
@@ -25,4 +42,4 @@ const Checkbox = React.forwardRef<
 ));
 Checkbox.displayName = CheckboxPrimitive.Root.displayName;
 
-export { Checkbox };
+export { Checkbox, type CheckboxProps };

package/src/lib/util/traverse.ts

@@ -1,13 +1,23 @@
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export type RecordAny = Record<string, any>;
 
-export const traverse = (
+type JsonPrimitive = string | number | boolean | null;
+type JsonArray = JsonValue[];
+type JsonObject = { [key: string]: JsonValue };
+type JsonValue = JsonPrimitive | JsonArray | JsonObject;
+
+export const traverse = <T extends JsonValue = RecordAny>(
   specification: RecordAny,
-  transform: (specification: RecordAny) => RecordAny,
+  transform: (specification: RecordAny) => T,
 ) => {
-  const result: RecordAny = {};
+  const transformed = transform(specification);
+  if (typeof transformed !== "object" || transformed === null) {
+    return transformed;
+  }
+
+  const result: RecordAny = Array.isArray(transformed) ? [] : {};
 
-  for (const [key, value] of Object.entries(specification)) {
+  for (const [key, value] of Object.entries(transformed)) {
     if (Array.isArray(value)) {
       result[key] = value.map((item) =>
         typeof item === "object" && item !== null
@@ -21,5 +31,5 @@ export const traverse = (
     }
   }
 
-  return transform(result);
+  return result;
 };