zudoku 0.0.0-fed343e → 0.0.0-feda542

package/src/lib/plugins/openapi/ParamInfos.tsx

@@ -0,0 +1,87 @@
+import { ChevronsLeftRightIcon } from "lucide-react";
+import { isValidElement, useState } from "react";
+import { InlineCode } from "../../components/InlineCode.js";
+import { type SchemaObject } from "../../oas/parser/index.js";
+import { cn } from "../../util/cn.js";
+
+const Pattern = ({ pattern }: { pattern: string }) => {
+  const [isExpanded, setIsExpanded] = useState(false);
+  const isExpandable = pattern.length > 20;
+  const shortPattern = isExpandable ? `${pattern.slice(0, 20)}…` : pattern;
+
+  return (
+    <InlineCode
+      className={cn("text-xs", isExpandable && "cursor-pointer")}
+      onClick={() => setIsExpanded(!isExpanded)}
+      selectOnClick={false}
+    >
+      {isExpanded ? pattern : shortPattern}
+      {isExpandable && (
+        <button type="button" className="p-1 translate-y-[2px]">
+          {!isExpanded && <ChevronsLeftRightIcon size={12} />}
+        </button>
+      )}
+    </InlineCode>
+  );
+};
+
+const getSchemaInfos = (schema?: SchemaObject) => {
+  if (!schema) return [];
+
+  return [
+    schema.type === "array" && schema.items.type
+      ? `${schema.items.type}[]`
+      : Array.isArray(schema.type)
+        ? schema.type.join(" | ")
+        : schema.type,
+
+    schema.enum && "enum",
+    schema.format,
+    schema.minimum && `min: ${schema.minimum}`,
+    schema.maximum && `max: ${schema.maximum}`,
+    schema.minLength && `minLength: ${schema.minLength}`,
+    schema.maxLength && `maxLength: ${schema.maxLength}`,
+    schema.minItems && `minItems: ${schema.minItems}`,
+    schema.maxItems && `maxItems: ${schema.maxItems}`,
+    schema.uniqueItems && "unique",
+    schema.minProperties && `minProps: ${schema.minProperties}`,
+    schema.maxProperties && `maxProps: ${schema.maxProperties}`,
+    schema.readOnly && "readOnly",
+    schema.writeOnly && "writeOnly",
+    schema.deprecated && "deprecated",
+    schema.pattern && (
+      <>
+        pattern: <Pattern pattern={schema.pattern} />
+      </>
+    ),
+  ];
+};
+
+export const ParamInfos = ({
+  schema,
+  extraItems = [],
+  className,
+}: {
+  schema?: SchemaObject;
+  extraItems?: unknown[];
+  className?: string;
+}) => {
+  const filteredItems = [...getSchemaInfos(schema), ...extraItems].flatMap(
+    (item) => (typeof item === "string" || isValidElement(item) ? item : []),
+  );
+
+  return (
+    <span className={className}>
+      {filteredItems.map((item, index) => (
+        <span className="text-muted-foreground" key={index}>
+          {item}
+          {index < filteredItems.length - 1 && (
+            <span className="text-muted-foreground/50">
+              &nbsp;&middot;&nbsp;
+            </span>
+          )}
+        </span>
+      ))}
+    </span>
+  );
+};

package/src/lib/plugins/openapi/ParameterList.tsx

@@ -1,3 +1,4 @@
+import { VisuallyHidden } from "@radix-ui/react-visually-hidden";
 import { Heading } from "../../components/Heading.js";
 import { Card } from "../../ui/Card.js";
 import type { ParameterGroup } from "./OperationListItem.js";
@@ -7,16 +8,19 @@ import {
 } from "./ParameterListItem.js";
 
 export const ParameterList = ({
+  summary,
   group,
   parameters,
   id,
 }: {
+  summary?: string;
   group: ParameterGroup;
   parameters: ParameterListItemResult[];
   id: string;
 }) => (
   <>
     <Heading level={3} id={`${id}/${group}-parameters`} className="capitalize">
+      {summary && <VisuallyHidden>{summary} &rsaquo; </VisuallyHidden>}
       {group === "header" ? "Headers" : `${group} Parameters`}
     </Heading>
     <Card>

package/src/lib/plugins/openapi/ParameterListItem.tsx

@@ -3,6 +3,10 @@ import { type SchemaObject } from "../../oas/graphql/index.js";
 import { ColorizedParam } from "./ColorizedParam.js";
 import type { OperationListItemResult } from "./OperationList.js";
 import type { ParameterGroup } from "./OperationListItem.js";
+import { ParamInfos } from "./ParamInfos.js";
+import { EnumValues } from "./components/EnumValues.js";
+import { SelectOnClick } from "./components/SelectOnClick.js";
+import { SchemaExampleAndDefault } from "./schema/SchemaExampleAndDefault.js";
 
 const getParameterSchema = (
   parameter: ParameterListItemResult,
@@ -27,36 +31,49 @@ export const ParameterListItem = ({
   parameter: ParameterListItemResult;
   group: ParameterGroup;
   id: string;
-}) => (
-  <li className="p-4 bg-border/20 text-sm flex flex-col gap-1">
-    <div className="flex items-center gap-2">
-      <code>
-        {group === "path" ? (
-          <ColorizedParam
-            name={parameter.name}
-            backgroundOpacity="15%"
-            slug={id + "-" + parameter.name.toLocaleLowerCase()}
-          />
-        ) : (
-          parameter.name
-        )}
-      </code>
-      {parameter.required && (
-        <span className="py-px px-1.5 font-medium bg-primary/75 text-muted rounded-lg">
-          required
-        </span>
+}) => {
+  const paramSchema = getParameterSchema(parameter);
+
+  return (
+    <li className="p-4 bg-border/20 text-sm flex flex-col gap-1.5">
+      <div className="flex items-center gap-2">
+        <SelectOnClick asChild>
+          <code>
+            {group === "path" ? (
+              <ColorizedParam
+                name={parameter.name}
+                backgroundOpacity="15%"
+                className="px-2"
+                slug={`${id}-${parameter.name}`}
+              />
+            ) : (
+              parameter.name
+            )}
+          </code>
+        </SelectOnClick>
+        <ParamInfos
+          schema={paramSchema}
+          extraItems={[
+            parameter.required && (
+              <span className="text-primary">required</span>
+            ),
+            parameter.style && `style: ${parameter.style}`,
+            parameter.explode && `explode: ${parameter.explode}`,
+          ]}
+        />
+      </div>
+      {parameter.description && (
+        <Markdown
+          content={parameter.description}
+          className="text-sm prose-p:my-1 prose-code:whitespace-pre-line"
+        />
       )}
-      {getParameterSchema(parameter).type && (
-        <span className="text-muted-foreground">
-          {getParameterSchema(parameter).type}
-        </span>
+      {paramSchema.type === "array" && paramSchema.items.enum ? (
+        <EnumValues values={paramSchema.items.enum} />
+      ) : (
+        paramSchema.enum && <EnumValues values={paramSchema.enum} />
       )}
-    </div>
-    {parameter.description && (
-      <Markdown
-        content={parameter.description}
-        className="text-sm prose-p:my-1 prose-code:whitespace-pre-line"
-      />
-    )}
-  </li>
-);
+      <SchemaExampleAndDefault schema={paramSchema} />
+    </li>
+  );
+};

package/src/lib/plugins/openapi/PlaygroundDialogWrapper.tsx

@@ -1,18 +1,33 @@
+import { useAuth } from "zudoku/components";
 import type { OperationListItemResult } from "./OperationList.js";
 import { PlaygroundDialog } from "./playground/PlaygroundDialog.js";
+import { Content } from "./SidecarExamples.js";
 
 export const PlaygroundDialogWrapper = ({
   server,
+  servers,
   operation,
+  examples,
 }: {
-  server: string;
+  server?: string;
+  servers?: string[];
   operation: OperationListItemResult;
+  examples?: Content;
 }) => {
+  const { isAuthEnabled, login, signup, isPending, isAuthenticated } =
+    useAuth();
+
   const headers = operation.parameters
     ?.filter((p) => p.in === "header")
+    .sort((a, b) => (a.required && !b.required ? -1 : 1))
     .map((p) => ({
       name: p.name,
-      defaultValue: p.examples?.find((x) => x.value)?.value ?? "",
+      defaultValue:
+        p.schema?.default ?? p.examples?.find((x) => x.value)?.value ?? "",
+      defaultActive: p.required ?? false,
+      isRequired: p.required ?? false,
+      enum: p.schema?.type == "array" ? p.schema?.items?.enum : p.schema?.enum,
+      type: p.schema?.type ?? "string",
     }));
   const queryParams = operation.parameters
     ?.filter((p) => p.in === "query")
@@ -21,6 +36,8 @@ export const PlaygroundDialogWrapper = ({
       name: p.name,
       defaultActive: p.required ?? false,
       isRequired: p.required ?? false,
+      enum: p.schema?.type == "array" ? p.schema?.items?.enum : p.schema?.enum,
+      type: p.schema?.type ?? "string",
     }));
   const pathParams = operation.parameters
     ?.filter((p) => p.in === "path")
@@ -29,11 +46,16 @@ export const PlaygroundDialogWrapper = ({
   return (
     <PlaygroundDialog
       server={server}
+      servers={servers}
       method={operation.method}
       url={operation.path}
       headers={headers}
       queryParams={queryParams}
       pathParams={pathParams}
+      examples={examples}
+      requiresLogin={isAuthEnabled && !isAuthenticated && !isPending}
+      onLogin={() => login()}
+      onSignUp={() => signup()}
     />
   );
 };

package/src/lib/plugins/openapi/RequestBodySidecarBox.tsx

@@ -1,39 +1,21 @@
-import { SyntaxHighlight } from "../../components/SyntaxHighlight.js";
-import { type SchemaObject } from "../../oas/graphql/index.js";
-import type { OperationListItemResult } from "./OperationList.js";
 import * as SidecarBox from "./SidecarBox.js";
-import { generateSchemaExample } from "./util/generateSchemaExample.js";
+import { type Content, SidecarExamples } from "./SidecarExamples.js";
 
-type Content = NonNullable<
-  NonNullable<OperationListItemResult["requestBody"]>["content"]
->;
-
-// @todo should we handle multiple content types?
-export const RequestBodySidecarBox = ({ content }: { content: Content }) => {
-  if (!content.length) return null;
+export const RequestBodySidecarBox = ({
+  content,
+  onExampleChange,
+}: {
+  content: Content;
+  onExampleChange?: (example: unknown) => void;
+}) => {
+  if (content.length === 0) return null;
 
   return (
-    <>
-      <SidecarBox.Root>
-        <SidecarBox.Head className="text-xs flex justify-between items-center">
-          <span className="font-mono">Request Body Example</span>
-        </SidecarBox.Head>
-        <SidecarBox.Body className="p-0">
-          <SyntaxHighlight
-            language="json"
-            noBackground
-            copyable
-            className="text-xs max-h-[450px] p-2"
-            code={JSON.stringify(
-              content.at(0)?.schema
-                ? generateSchemaExample(content[0].schema as SchemaObject)
-                : "",
-              null,
-              2,
-            )}
-          />
-        </SidecarBox.Body>
-      </SidecarBox.Root>
-    </>
+    <SidecarBox.Root>
+      <SidecarBox.Head className="text-xs flex justify-between items-center">
+        <span className="font-mono">Request Body Example</span>
+      </SidecarBox.Head>
+      <SidecarExamples content={content} onExampleChange={onExampleChange} />
+    </SidecarBox.Root>
   );
 };

package/src/lib/plugins/openapi/ResponsesSidecarBox.tsx

@@ -1,12 +1,22 @@
 import * as Tabs from "@radix-ui/react-tabs";
-import { SyntaxHighlight } from "../../components/SyntaxHighlight.js";
-import { type SchemaObject } from "../../oas/graphql/index.js";
 import { cn } from "../../util/cn.js";
 import type { OperationListItemResult } from "./OperationList.js";
 import * as SidecarBox from "./SidecarBox.js";
-import { generateSchemaExample } from "./util/generateSchemaExample.js";
+import { SidecarExamples } from "./SidecarExamples.js";
 
 type Responses = OperationListItemResult["responses"];
+
+const ResponseContent = ({ response }: { response: Responses[number] }) => {
+  return (
+    <Tabs.Content value={response.statusCode}>
+      <SidecarExamples
+        content={response.content ?? []}
+        description={response.description ?? undefined}
+      />
+    </Tabs.Content>
+  );
+};
+
 export const ResponsesSidecarBox = ({
   responses,
   selectedResponse,
@@ -15,58 +25,36 @@ export const ResponsesSidecarBox = ({
   responses: Responses;
   selectedResponse?: string;
   onSelectResponse: (response: string) => void;
-}) => (
-  <SidecarBox.Root>
-    <Tabs.Root
-      defaultValue={responses[0]?.statusCode}
-      value={selectedResponse}
-      onValueChange={(value) => onSelectResponse(value)}
-    >
-      <SidecarBox.Head className="text-xs flex flex-col gap-2 pb-0">
-        <span className="font-mono">Example Responses</span>
-        <Tabs.List className="flex gap-2">
-          {responses.map((response) => (
-            <Tabs.Trigger
-              key={response.statusCode}
-              value={response.statusCode}
-              className={cn(
-                "text-xs font-mono px-1.5 py-1 pb-px translate-y-px border-b-2 border-transparent rounded-t cursor-pointer",
-                "data-[state=active]:text-primary data-[state=active]:dark:text-inherit data-[state=active]:border-primary",
-                "hover:border-accent-foreground/25",
-              )}
-            >
-              {response.statusCode}
-            </Tabs.Trigger>
-          ))}
-        </Tabs.List>
-      </SidecarBox.Head>
-      {responses.map((response) => {
-        const schema = response.content?.[0]?.schema as
-          | SchemaObject
-          | undefined;
-
-        return (
-          <Tabs.Content key={response.statusCode} value={response.statusCode}>
-            <SidecarBox.Body className="p-0">
-              {schema ? (
-                <SyntaxHighlight
-                  language="json"
-                  noBackground
-                  className="text-xs max-h-[450px] p-2"
-                  code={JSON.stringify(generateSchemaExample(schema), null, 2)}
-                />
-              ) : (
-                <span className="text-muted-foreground font-mono italic text-xs">
-                  Empty Response
-                </span>
-              )}
-            </SidecarBox.Body>
-            <SidecarBox.Footer className="flex justify-end text-xs">
-              {response.description}
-            </SidecarBox.Footer>
-          </Tabs.Content>
-        );
-      })}
-    </Tabs.Root>
-  </SidecarBox.Root>
-);
+}) => {
+  return (
+    <SidecarBox.Root>
+      <Tabs.Root
+        defaultValue={responses[0]?.statusCode}
+        value={selectedResponse}
+        onValueChange={(value) => onSelectResponse(value)}
+      >
+        <SidecarBox.Head className="text-xs flex flex-col gap-2 pb-0">
+          <span className="font-mono">Example Responses</span>
+          <Tabs.List className="flex gap-2">
+            {responses.map((response) => (
+              <Tabs.Trigger
+                key={response.statusCode}
+                value={response.statusCode}
+                className={cn(
+                  "text-xs font-mono px-1.5 py-1 pb-px translate-y-px border-b-2 border-transparent rounded-t cursor-pointer",
+                  "data-[state=active]:text-primary data-[state=active]:dark:text-inherit data-[state=active]:border-primary",
+                  "hover:border-accent-foreground/25",
+                )}
+              >
+                {response.statusCode}
+              </Tabs.Trigger>
+            ))}
+          </Tabs.List>
+        </SidecarBox.Head>
+        {responses.map((response) => (
+          <ResponseContent key={response.statusCode} response={response} />
+        ))}
+      </Tabs.Root>
+    </SidecarBox.Root>
+  );
+};

package/src/lib/plugins/openapi/SchemaList.tsx

@@ -0,0 +1,151 @@
+import slugify from "@sindresorhus/slugify";
+import { useSuspenseQuery } from "@tanstack/react-query";
+import {
+  ChevronRightIcon,
+  ChevronsDownUpIcon,
+  ChevronsUpDownIcon,
+} from "lucide-react";
+import { Button } from "zudoku/ui/Button.js";
+import {
+  Collapsible,
+  CollapsibleContent,
+  CollapsibleTrigger,
+} from "zudoku/ui/Collapsible.js";
+import { CategoryHeading } from "../../components/CategoryHeading.js";
+import { Heading } from "../../components/Heading.js";
+import { Markdown, ProseClasses } from "../../components/Markdown.js";
+import { Toc } from "../../components/navigation/Toc.js";
+import { cn } from "../../util/cn.js";
+import { useCreateQuery } from "./client/useCreateQuery.js";
+import { useOasConfig } from "./context.js";
+import { graphql } from "./graphql/gql.js";
+import { SchemaView } from "./schema/SchemaView.js";
+
+const GET_SCHEMAS = graphql(/* GraphQL */ `
+  query GetSchemas($input: JSON!, $type: SchemaType!) {
+    schema(input: $input, type: $type) {
+      title
+      description
+      summary
+      components {
+        schemas {
+          name
+          schema
+          extensions
+        }
+      }
+    }
+  }
+`);
+
+export function SchemaList() {
+  const { input, type, versions, version, options } = useOasConfig();
+  const schemasQuery = useCreateQuery(GET_SCHEMAS, {
+    input,
+    type,
+  });
+  const { data } = useSuspenseQuery(schemasQuery);
+
+  const schemas = data.schema.components?.schemas ?? [];
+
+  if (!schemas.length) {
+    return <div>No schemas found</div>;
+  }
+
+  const hasMultipleVersions = Object.entries(versions).length > 1;
+  const showVersions =
+    options?.showVersionSelect === "always" ||
+    (hasMultipleVersions && options?.showVersionSelect !== "hide");
+
+  return (
+    <div
+      className="grid grid-cols-[--sidecar-grid-cols] gap-8 justify-between"
+      data-pagefind-filter="section:openapi"
+      data-pagefind-meta="section:openapi"
+    >
+      <div className="pt-[--padding-content-top] pb-[--padding-content-bottom]">
+        <Collapsible className="w-full">
+          <div className="flex flex-col gap-y-4 sm:flex-row justify-around items-start sm:items-end">
+            <div className="flex-1">
+              <CategoryHeading>{data.schema.title}</CategoryHeading>
+              <Heading
+                level={1}
+                id="schemas"
+                registerSidebarAnchor
+                className="mb-0"
+              >
+                Schemas
+                {showVersions && (
+                  <span className="text-xl text-muted-foreground ml-1.5">
+                    ({version})
+                  </span>
+                )}
+              </Heading>
+            </div>
+            {data.schema.description && (
+              <CollapsibleTrigger className="flex items-center gap-1 text-sm font-medium text-muted-foreground group">
+                <span>API information</span>
+                <ChevronsUpDownIcon
+                  className="group-data-[state=open]:hidden translate-y-px"
+                  size={14}
+                />
+                <ChevronsDownUpIcon
+                  className="group-data-[state=closed]:hidden translate-y-px"
+                  size={13}
+                />
+              </CollapsibleTrigger>
+            )}
+          </div>
+          {data.schema.description && (
+            <CollapsibleContent className="CollapsibleContent">
+              <div
+                className={cn(
+                  ProseClasses,
+                  "pt-4 max-w-full prose-img:max-w-prose",
+                )}
+              >
+                <Markdown
+                  className="border rounded bg-muted/25 border-border px-2.5 md:px-4"
+                  content={data.schema.description}
+                />
+              </div>
+            </CollapsibleContent>
+          )}
+        </Collapsible>
+        <hr className="my-8" />
+        <div className="flex flex-col gap-y-5">
+          {schemas.map((schema) => (
+            <Collapsible key={schema.name} className="group" defaultOpen>
+              <Heading
+                registerSidebarAnchor
+                level={2}
+                className="flex items-center gap-1 justify-between w-fit"
+                id={slugify(schema.name)}
+              >
+                {schema.name}{" "}
+                <CollapsibleTrigger asChild>
+                  <Button variant="ghost" size="icon" className="size-6">
+                    <ChevronRightIcon
+                      size={16}
+                      className="group-data-[state=open]:rotate-90 transition cursor-pointer"
+                    />
+                  </Button>
+                </CollapsibleTrigger>
+              </Heading>
+              <CollapsibleContent className="mt-4 CollapsibleContent">
+                <SchemaView schema={schema.schema} />
+              </CollapsibleContent>
+            </Collapsible>
+          ))}
+        </div>
+      </div>
+      <Toc
+        entries={schemas.map((schema) => ({
+          id: slugify(schema.name),
+          value: schema.name,
+          depth: 1,
+        }))}
+      />
+    </div>
+  );
+}