zudoku 0.0.0-reset-hash-value.ac516c6d → 0.0.0-z06bf8c86

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

@@ -1,15 +1,15 @@
 import * as Collapsible from "@radix-ui/react-collapsible";
 import { MinusIcon, PlusIcon, RefreshCcwDotIcon } from "lucide-react";
 import { useState } from "react";
+import { Item, ItemActions, ItemContent, ItemTitle } from "zudoku/ui/Item.js";
 import { InlineCode } from "../../../components/InlineCode.js";
 import { Markdown } from "../../../components/Markdown.js";
 import type { SchemaObject } from "../../../oas/parser/index.js";
 import { Button } from "../../../ui/Button.js";
+import { cn } from "../../../util/cn.js";
 import { ConstValue } from "../components/ConstValue.js";
 import { EnumValues } from "../components/EnumValues.js";
-import { SelectOnClick } from "../components/SelectOnClick.js";
 import { ParamInfos } from "../ParamInfos.js";
-import { AllOfGroupView } from "./AllOfGroup/AllOfGroupView.js";
 import { SchemaExampleAndDefault } from "./SchemaExampleAndDefault.js";
 import { SchemaView } from "./SchemaView.js";
 import {
@@ -22,7 +22,7 @@ import {
 
 const RecursiveIndicator = ({ circularProp }: { circularProp?: string }) => (
   <InlineCode
-    className="inline-flex items-center gap-1.5 italic text-xs translate-y-0.5"
+    className="inline-flex items-center gap-1.5 text-xs translate-y-0.5"
     selectOnClick={false}
   >
     <RefreshCcwDotIcon size={13} />
@@ -47,18 +47,26 @@ export const SchemaPropertyItem = ({
 
   if (isCircularRef(schema)) {
     return (
-      <li className="p-4 bg-border/20 hover:bg-border/30">
-        <div className="flex flex-col gap-2.5 justify-between text-sm">
-          <div className="space-x-2 rtl:space-x-reverse">
-            <code>{name}</code>
+      <Item>
+        <ItemContent className="gap-y-2">
+          <div>
+            <ItemTitle className="inline me-2">
+              <code>{name}</code>
+            </ItemTitle>
             <ParamInfos
+              className="inline"
               schema={schema}
-              extraItems={[<RecursiveIndicator key="circular-ref" />]}
+              extraItems={[
+                group !== "optional" && (
+                  <span className="text-primary">required</span>
+                ),
+                <RecursiveIndicator key="circular-ref" />,
+              ]}
             />
           </div>
           <SchemaExampleAndDefault schema={schema} />
-        </div>
-      </li>
+        </ItemContent>
+      </Item>
     );
   }
 
@@ -74,14 +82,34 @@ export const SchemaPropertyItem = ({
       !isArrayCircularRef(schema),
   );
 
+  const shouldRenderDescription = Boolean(
+    schema.description ||
+      ("items" in schema && schema.items?.enum) ||
+      schema.const ||
+      schema.enum ||
+      schema.example !== undefined ||
+      schema.default !== undefined,
+  );
+
   return (
-    <li className="p-4 bg-border/20 hover:bg-border/30">
-      <div className="flex flex-col gap-2.5 justify-between text-sm">
-        <div className="space-x-2 rtl:space-x-reverse">
-          <SelectOnClick asChild>
-            <code>{name}</code>
-          </SelectOnClick>
+    <Item>
+      <ItemContent className="gap-y-2">
+        <div>
+          <ItemTitle className="inline me-2">
+            {isCollapsible ? (
+              <button
+                onClick={() => setIsOpen(!isOpen)}
+                type="button"
+                className="hover:underline"
+              >
+                <code>{name}</code>
+              </button>
+            ) : (
+              <code>{name}</code>
+            )}
+          </ItemTitle>
           <ParamInfos
+            className="inline"
             schema={schema}
             extraItems={[
               group !== "optional" && (
@@ -95,47 +123,53 @@ export const SchemaPropertyItem = ({
             ]}
           />
         </div>
-        {schema.description && (
-          <Markdown
-            className="text-sm leading-normal"
-            content={schema.description}
-          />
-        )}
-        {schema.type === "array" && "items" in schema && schema.items.enum && (
-          <EnumValues values={schema.items.enum} />
+        {shouldRenderDescription && (
+          <div className="flex flex-col gap-1.5">
+            {schema.description && (
+              <Markdown className="prose-sm" content={schema.description} />
+            )}
+            {"items" in schema && schema.items?.enum && (
+              <EnumValues values={schema.items.enum} />
+            )}
+            {schema.const && <ConstValue schema={schema} hideDescription />}
+            {schema.enum && <EnumValues values={schema.enum} />}
+            <SchemaExampleAndDefault schema={schema} />
+          </div>
         )}
-        {schema.const && <ConstValue schema={schema} hideDescription />}
-        {schema.enum && <EnumValues values={schema.enum} />}
-        <SchemaExampleAndDefault schema={schema} />
+      </ItemContent>
 
-        {isCollapsible && (
-          <Collapsible.Root
-            defaultOpen={defaultOpen}
-            open={isOpen}
-            onOpenChange={() => setIsOpen(!isOpen)}
+      {isCollapsible && showCollapseButton && (
+        <ItemActions className="self-start">
+          <Button
+            variant="ghost"
+            size="icon"
+            className="rounded-full"
+            onClick={() => setIsOpen(!isOpen)}
+            aria-label="Toggle properties"
           >
-            {showCollapseButton && (
-              <Collapsible.Trigger asChild>
-                <Button variant="expand" size="sm">
-                  {isOpen ? <MinusIcon size={12} /> : <PlusIcon size={12} />}
-                  {!isOpen ? "Show properties" : "Hide properties"}
-                </Button>
-              </Collapsible.Trigger>
-            )}
-            <Collapsible.Content>
-              <div className="mt-2">
-                {schema.allOf ? (
-                  <AllOfGroupView schema={schema} />
-                ) : schema.anyOf || schema.oneOf || schema.type === "object" ? (
-                  <SchemaView schema={schema} />
-                ) : isArrayType(schema) && "items" in schema ? (
-                  <SchemaView schema={schema.items} />
-                ) : null}
-              </div>
-            </Collapsible.Content>
-          </Collapsible.Root>
-        )}
-      </div>
-    </li>
+            {isOpen ? <MinusIcon size={16} /> : <PlusIcon size={16} />}
+          </Button>
+        </ItemActions>
+      )}
+
+      {isCollapsible && (
+        <Collapsible.Root
+          defaultOpen={defaultOpen}
+          open={isOpen}
+          onOpenChange={setIsOpen}
+          className={cn("w-full", !isOpen && "contents")}
+        >
+          <Collapsible.Content asChild>
+            <ItemContent>
+              {schema.anyOf || schema.oneOf || schema.type === "object" ? (
+                <SchemaView schema={schema} />
+              ) : isArrayType(schema) && "items" in schema ? (
+                <SchemaView schema={schema.items} />
+              ) : null}
+            </ItemContent>
+          </Collapsible.Content>
+        </Collapsible.Root>
+      )}
+    </Item>
   );
 };

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

@@ -1,16 +1,23 @@
 import { InfoIcon } from "lucide-react";
+import { Fragment } from "react";
+import {
+  Frame,
+  FrameDescription,
+  FrameFooter,
+  FrameHeader,
+  FramePanel,
+} from "zudoku/ui/Frame.js";
+import { ItemGroup, ItemSeparator } from "zudoku/ui/Item.js";
 import { Markdown } from "../../../components/Markdown.js";
 import type { SchemaObject } from "../../../oas/parser/index.js";
-import { Card } from "../../../ui/Card.js";
 import { groupBy } from "../../../util/groupBy.js";
 import { ConstValue } from "../components/ConstValue.js";
 import { EnumValues } from "../components/EnumValues.js";
 import { ParamInfos } from "../ParamInfos.js";
-import { AllOfGroupView } from "./AllOfGroup/AllOfGroupView.js";
 import { SchemaExampleAndDefault } from "./SchemaExampleAndDefault.js";
 import { SchemaPropertyItem } from "./SchemaPropertyItem.js";
 import { UnionView } from "./UnionView.js";
-import { isBasicType } from "./utils.js";
+import { isArrayType, isBasicType } from "./utils.js";
 
 const renderMarkdown = (content?: string) =>
   content && (
@@ -23,19 +30,30 @@ const renderMarkdown = (content?: string) =>
 const renderBasicSchema = (
   schema: SchemaObject,
   cardHeader?: React.ReactNode,
-) => (
-  <Card className="overflow-hidden">
-    {cardHeader}
-    <div className="p-4 space-y-2">
+  embedded?: boolean,
+) => {
+  const content = (
+    <>
       <span className="text-sm text-muted-foreground">
         <ParamInfos schema={schema} />
       </span>
       {schema.enum && <EnumValues values={schema.enum} />}
       {renderMarkdown(schema.description)}
       <SchemaExampleAndDefault schema={schema} />
-    </div>
-  </Card>
-);
+    </>
+  );
+
+  if (embedded) {
+    return <div className="space-y-2 p-4">{content}</div>;
+  }
+
+  return (
+    <Frame>
+      {cardHeader}
+      <FramePanel className="space-y-2">{content}</FramePanel>
+    </Frame>
+  );
+};
 
 export const SchemaView = ({
   schema,
@@ -50,12 +68,14 @@ export const SchemaView = ({
 }) => {
   if (!schema || Object.keys(schema).length === 0) {
     return (
-      <Card className="overflow-hidden">
+      <Frame>
         {cardHeader}
-        <div className="text-sm text-muted-foreground italic p-4">
-          No data returned
-        </div>
-      </Card>
+        <FramePanel>
+          <div className="text-sm text-muted-foreground italic">
+            No data returned
+          </div>
+        </FramePanel>
+      </Frame>
     );
   }
 
@@ -67,18 +87,24 @@ export const SchemaView = ({
     return <UnionView schema={schema} cardHeader={cardHeader} />;
   }
 
-  if (Array.isArray(schema.allOf)) {
-    return <AllOfGroupView schema={schema} cardHeader={cardHeader} />;
-  }
-
   if (isBasicType(schema.type)) {
-    return renderBasicSchema(schema, cardHeader);
+    return renderBasicSchema(schema, cardHeader, embedded);
   }
 
-  if (schema.type === "array" && typeof schema.items === "object") {
-    return <SchemaView schema={schema.items} cardHeader={cardHeader} />;
+  if (isArrayType(schema) && typeof schema.items === "object") {
+    const wrappedSchema: SchemaObject = {
+      type: "object",
+      properties: { "": schema },
+    };
+
+    return (
+      <SchemaView schema={wrappedSchema} cardHeader={cardHeader} defaultOpen />
+    );
   }
 
+  const additionalObjectProperties = typeof schema.additionalProperties ===
+    "object" && <SchemaView schema={schema.additionalProperties} embedded />;
+
   if (schema.type === "object") {
     const groupedProperties = groupBy(
       Object.entries(schema.properties ?? {}),
@@ -90,50 +116,64 @@ export const SchemaView = ({
             : "optional";
       },
     );
+
     const groupNames = ["required", "optional", "deprecated"] as const;
+    const groups = groupNames.flatMap((group) => {
+      const properties = groupedProperties[group];
+      return properties ? { group, properties } : [];
+    });
 
-    const additionalProperties =
-      typeof schema.additionalProperties === "object" ? (
-        <SchemaView schema={schema.additionalProperties} embedded />
-      ) : schema.additionalProperties === true ? (
-        <div className="text-sm p-4 bg-border/20 hover:bg-border/30 flex items-center gap-1">
-          <span>Additional properties are allowed</span>
-          <a
-            className="p-0.5 -m-0.5"
-            href="https://swagger.io/docs/specification/v3_0/data-models/dictionaries/"
-            rel="noopener noreferrer"
-            target="_blank"
-          >
-            <InfoIcon size={14} />
-          </a>
-        </div>
-      ) : null;
-
-    const Component = embedded ? "div" : Card;
+    const itemsList = groups.map(({ group, properties }, index) => (
+      <Fragment key={group}>
+        {index > 0 && <ItemSeparator />}
+        <ItemGroup className="overflow-clip">
+          {properties.map(([name, schema], index) => (
+            <Fragment key={name}>
+              {index > 0 && <ItemSeparator />}
+              <SchemaPropertyItem
+                name={name}
+                schema={schema}
+                group={group}
+                defaultOpen={defaultOpen}
+              />
+            </Fragment>
+          ))}
+        </ItemGroup>
+      </Fragment>
+    ));
+
+    if (embedded) {
+      return itemsList;
+    }
 
     return (
-      <Component className="divide-y overflow-hidden">
+      <Frame>
         {cardHeader}
-        {groupNames.map(
-          (group) =>
-            groupedProperties[group] && (
-              <ul key={group} className="divide-y">
-                {groupedProperties[group].map(([name, schema]) => (
-                  <SchemaPropertyItem
-                    key={name}
-                    name={name}
-                    schema={schema}
-                    group={group}
-                    defaultOpen={defaultOpen}
-                  />
-                ))}
-              </ul>
-            ),
+        {schema.description && (
+          <FrameHeader>
+            <FrameDescription>{schema.description}</FrameDescription>
+          </FrameHeader>
+        )}
+        {(itemsList.length > 0 || additionalObjectProperties) && (
+          <FramePanel className="p-0!">
+            {itemsList}
+            {additionalObjectProperties}
+          </FramePanel>
         )}
-        {additionalProperties}
-      </Component>
+        {schema.additionalProperties === true && (
+          <FrameFooter>
+            <a
+              className="text-sm flex items-center gap-1 hover:underline"
+              href="https://swagger.io/docs/specification/v3_0/data-models/dictionaries/"
+              rel="noopener noreferrer"
+              target="_blank"
+            >
+              Additional properties are allowed
+              <InfoIcon size={14} />
+            </a>
+          </FrameFooter>
+        )}
+      </Frame>
     );
   }
-
-  return null;
 };

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

@@ -1,7 +1,7 @@
 import { useState } from "react";
 import type { SchemaObject } from "../../../oas/parser/index.js";
 import { Badge } from "../../../ui/Badge.js";
-import { Card } from "../../../ui/Card.js";
+import { Frame, FramePanel } from "../../../ui/Frame.js";
 import { cn } from "../../../util/cn.js";
 import { SchemaView } from "./SchemaView.js";
 import {
@@ -67,17 +67,6 @@ const DecisionTable = ({
   );
 };
 
-const VariantPanel = ({ variant }: { variant: SchemaObject }) => {
-  return (
-    <div className="space-y-2">
-      {variant.description && (
-        <p className="text-sm text-muted-foreground">{variant.description}</p>
-      )}
-      <SchemaView schema={variant} />
-    </div>
-  );
-};
-
 export const UnionView = ({
   schema,
   cardHeader,
@@ -119,9 +108,9 @@ export const UnionView = ({
     currentVariantIndex >= 0 ? variants[currentVariantIndex] : null;
 
   return (
-    <Card className="overflow-hidden text-sm">
+    <Frame>
       {cardHeader}
-      <div className="flex flex-col gap-4 p-4">
+      <FramePanel className="text-sm flex flex-col gap-4">
         <div className="flex items-center gap-2">
           <Badge variant="outline">{mode}</Badge>
           <div className="flex-1 p-2">
@@ -136,8 +125,8 @@ export const UnionView = ({
           onSelectVariant={setSelectedVariant}
         />
         <strong>Properties for {selectedVariant}:</strong>
-        {currentVariant && <VariantPanel variant={currentVariant} />}
-      </div>
-    </Card>
+        {currentVariant && <SchemaView schema={currentVariant} />}
+      </FramePanel>
+    </Frame>
   );
 };

package/src/lib/plugins/openapi/schema/union-helpers.ts

@@ -36,7 +36,6 @@ export const unionVariants = (schema: SchemaObject): SchemaObject[] => {
       const shouldInherit =
         !variant.properties &&
         !variant.type &&
-        !variant.allOf &&
         !variant.oneOf &&
         !variant.anyOf;
 

package/src/lib/plugins/openapi/schema/utils.ts

@@ -1,5 +1,11 @@
-import { CIRCULAR_REF } from "../../../oas/graphql/circular.js";
-import type { SchemaObject } from "../../../oas/parser/index.js";
+import {
+  CIRCULAR_REF,
+  SCHEMA_REF_PREFIX,
+} from "../../../oas/graphql/circular.js";
+import type {
+  ArraySchemaObject,
+  SchemaObject,
+} from "../../../oas/parser/index.js";
 
 export const isBasicType = (
   type: unknown,
@@ -8,7 +14,7 @@ export const isBasicType = (
     ["string", "number", "boolean", "integer", "null"].includes(type)) ||
   (Array.isArray(type) && type.every(isBasicType));
 
-export const isArrayType = (value: SchemaObject) =>
+export const isArrayType = (value: SchemaObject): value is ArraySchemaObject =>
   value.type === "array" ||
   // schema.type might be an array of types, so we need to check if "array" is one of them
   (Array.isArray(value.type) && value.type.includes("array"));
@@ -22,7 +28,8 @@ export const isComplexType = (value?: SchemaObject) =>
       (!value.items.type || value.items.type === "object")));
 
 export const isCircularRef = (schema: unknown): schema is string =>
-  typeof schema === "string" && schema.startsWith(CIRCULAR_REF);
+  typeof schema === "string" &&
+  (schema.startsWith(CIRCULAR_REF) || schema.startsWith(SCHEMA_REF_PREFIX));
 
 export const isArrayCircularRef = (
   schema: SchemaObject,
@@ -31,5 +38,12 @@ export const isArrayCircularRef = (
 
 export const extractCircularRefInfo = (
   ref?: string | SchemaObject,
-): string | undefined =>
-  typeof ref === "string" ? ref.split(":")[1] : undefined;
+): string | undefined => {
+  if (typeof ref !== "string") return undefined;
+
+  if (ref.startsWith(SCHEMA_REF_PREFIX)) {
+    return ref.slice(SCHEMA_REF_PREFIX.length).split("/").pop();
+  }
+
+  return ref.split(":")[1];
+};

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

@@ -1,6 +1,23 @@
 import { HTTPSnippet } from "@zudoku/httpsnippet";
 import type { OperationsFragmentFragment } from "../graphql/graphql.js";
 
+const toFormDataParams = (text?: string) => {
+  const stringify = (v: unknown) =>
+    typeof v === "string" ? v : JSON.stringify(v);
+
+  try {
+    const obj = text && JSON.parse(text);
+    if (typeof obj !== "object" || !obj) return [];
+
+    return Object.entries(obj).flatMap(([name, value]) => {
+      const values = Array.isArray(value) ? value : [value];
+      return values.map((v) => ({ name, value: stringify(v) }));
+    });
+  } catch {
+    return [];
+  }
+};
+
 export const createHttpSnippet = ({
   operation,
   selectedServer,
@@ -13,11 +30,22 @@ export const createHttpSnippet = ({
     text?: string;
   };
 }) => {
+  const isMultipart =
+    exampleBody.mimeType === "multipart/form-data" ||
+    exampleBody.mimeType === "application/x-www-form-urlencoded";
+
+  const postData = isMultipart
+    ? {
+        mimeType: exampleBody.mimeType,
+        params: toFormDataParams(exampleBody.text),
+      }
+    : exampleBody;
+
   return new HTTPSnippet({
     method: operation.method.toUpperCase(),
     url:
       selectedServer + operation.path.replaceAll("{", ":").replaceAll("}", ""),
-    postData: exampleBody,
+    postData,
     headers: [
       ...(exampleBody.text
         ? [{ name: "Content-Type", value: exampleBody.mimeType }]

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

@@ -85,23 +85,23 @@ export const generateSchemaExample = (
     return schema.enum[0];
   }
 
-  if (schema.oneOf) {
-    const randomIndex = Math.floor(Math.random() * schema.oneOf.length);
-    return generateSchemaExample(schema.oneOf[randomIndex] as SchemaObject);
+  if (schema.oneOf && schema.oneOf.length > 0) {
+    return generateSchemaExample(schema.oneOf[0]);
   }
 
-  if (schema.anyOf) {
+  if (schema.anyOf && schema.anyOf.length > 0) {
     // Should likely be expanded to return a partial set of values, but it would require
     // detection if being used within an array or a string type.
-    const randomIndex = Math.floor(Math.random() * schema.anyOf.length);
-    return generateSchemaExample(schema.anyOf[randomIndex] as SchemaObject);
+    return generateSchemaExample(schema.anyOf[0]);
   }
 
-  if (schema.allOf) {
-    // https://swagger.io/docs/specification/v3_0/data-models/oneof-anyof-allof-not/#allof
-    return schema.allOf.reduce((acc, allOfSchema) => {
-      return { ...acc, ...generateSchemaExample(allOfSchema as SchemaObject) };
-    }, {});
+  // Check for property-level examples
+  if (
+    schema.examples &&
+    Array.isArray(schema.examples) &&
+    schema.examples.length > 0
+  ) {
+    return schema.examples[0];
   }
 
   switch (schema.type) {

package/src/lib/plugins/openapi/util/getRoutes.tsx

@@ -148,8 +148,21 @@ const createVersionRoutes = (
   ];
 };
 
-export const getVersions = (config: OasPluginConfig) =>
-  config.type === "file" ? Object.keys(config.input) : [];
+export const getVersionMetadata = (config: OasPluginConfig) => {
+  if (config.type === "raw" || !Array.isArray(config.input)) {
+    return { versions: [], labels: {}, downloadUrls: {} };
+  }
+
+  return {
+    versions: config.input.map((v) => v.path),
+    labels: Object.fromEntries(
+      config.input.map((v) => [v.path, v.label ?? v.path]),
+    ),
+    downloadUrls: Object.fromEntries(
+      config.input.map((v) => [v.path, v.downloadUrl]),
+    ),
+  };
+};
 
 export const getRoutes = ({
   basePath,
@@ -161,10 +174,33 @@ export const getRoutes = ({
   basePath: string;
 }): RouteObject[] => {
   const tagPages = config.tagPages;
+  const { versions } = getVersionMetadata(config);
 
   // If the config does not provide tag pages the catch-all
   // route handles all operations on a single page
   if (!tagPages) {
+    // If there are versions, create versioned routes even without tag pages
+    if (versions.length > 0) {
+      const versionsInPath =
+        versions.length > 1 ? [undefined, ...versions] : [undefined];
+
+      return versionsInPath.map((version) => {
+        const versionPath = joinUrl(basePath, version);
+        return createOasProvider({
+          basePath,
+          version,
+          routePath: versionPath,
+          routes: [
+            createNonTagPagesRoute({ path: `${versionPath}/:tag?` }),
+            ...createAdditionalRoutes(versionPath),
+          ],
+          client,
+          config,
+        });
+      });
+    }
+
+    // No versions, single route
     return [
       createOasProvider({
         basePath,
@@ -179,7 +215,6 @@ export const getRoutes = ({
     ];
   }
 
-  const versions = getVersions(config);
   // The latest version always is added as index path
   const versionsInPath =
     versions.length > 1 ? [undefined, ...versions] : [undefined];