@lukoweb/apitogo 0.1.24 → 0.1.37

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

@@ -1,123 +1,123 @@
-import type { SchemaObject } from "../../../oas/parser/index.js";
-
-export type FieldSignature = {
-  type?: SchemaObject["type"];
-  const?: unknown;
-  enum?: unknown[];
-  format?: string;
-  pattern?: string;
-  minimum?: number;
-  maximum?: number;
-  exclusiveMinimum?: boolean | number;
-  exclusiveMaximum?: boolean | number;
-  minLength?: number;
-  maxLength?: number;
-  minItems?: number;
-  maxItems?: number;
-  itemsType?: string | string[];
-  additionalProps?: "true" | "false" | "schema";
-};
-
-export type FieldDoc = {
-  name: string;
-  humanType: string;
-  description?: string;
-  requiredInAll: boolean;
-};
-
-export const unionVariants = (schema: SchemaObject): SchemaObject[] => {
-  const variants = (schema.oneOf ?? schema.anyOf ?? []) as SchemaObject[];
-
-  // If parent schema has properties that variants don't, merge them
-  // This handles the pattern where anyOf/oneOf is used just for required field combinations
-  if (schema.properties && Object.keys(schema.properties).length > 0) {
-    return variants.map((variant) => {
-      // If variant doesn't define its own properties or type, inherit from parent
-      const shouldInherit =
-        !variant.properties &&
-        !variant.type &&
-        !variant.oneOf &&
-        !variant.anyOf;
-
-      if (shouldInherit) {
-        return {
-          ...variant,
-          type: "object" as const,
-          properties: schema.properties,
-          required: variant.required ?? schema.required,
-        };
-      }
-
-      return variant;
-    });
-  }
-
-  return variants;
-};
-
-export const decideExclusivity = (
-  schema: SchemaObject,
-): "exactly-one" | "at-least-one" => {
-  if (Array.isArray(schema.oneOf)) return "exactly-one";
-
-  const discriminator = schema.discriminator?.propertyName;
-  if (!discriminator) return "at-least-one";
-
-  const variants = unionVariants(schema);
-  const seen = new Set<string>();
-
-  for (const variant of variants) {
-    const prop = variant.properties?.[discriminator];
-
-    const value =
-      prop?.const ??
-      (Array.isArray(prop?.enum) && prop.enum.length === 1
-        ? String(prop.enum[0])
-        : undefined);
-
-    if (value == null || seen.has(String(value))) return "at-least-one";
-    seen.add(String(value));
-  }
-
-  return "exactly-one";
-};
-
-export const labelForVariant = (index: number, variant: SchemaObject) =>
-  variant.title?.trim() || `Variant ${index + 1}`;
-
-export const quickGuards = (variant: SchemaObject, root?: SchemaObject) => {
-  const guards: string[] = [];
-
-  if (variant.type) {
-    guards.push(
-      `type = ${Array.isArray(variant.type) ? variant.type.join("|") : variant.type}`,
-    );
-  }
-
-  const discriminator = root?.discriminator?.propertyName;
-  if (discriminator) {
-    const discriminatorProp = variant.properties?.[discriminator] as
-      | SchemaObject
-      | undefined;
-
-    const discriminatorValue =
-      discriminatorProp?.const ??
-      (Array.isArray(discriminatorProp?.enum) &&
-      discriminatorProp.enum.length === 1
-        ? discriminatorProp.enum[0]
-        : undefined);
-
-    if (discriminatorValue !== undefined) {
-      guards.push(`${discriminator}=${JSON.stringify(discriminatorValue)}`);
-    }
-  }
-
-  const required = (variant.required ?? []).filter((k) => k !== discriminator);
-  if (required.length) {
-    const head = required.slice(0, 3).join(", ");
-    const more = required.length > 3 ? ` +${required.length - 3} more` : "";
-    guards.push(`requires: ${head}${more}`);
-  }
-
-  return guards;
-};
+import type { SchemaObject } from "../../../oas/parser/index.js";
+
+export type FieldSignature = {
+  type?: SchemaObject["type"];
+  const?: unknown;
+  enum?: unknown[];
+  format?: string;
+  pattern?: string;
+  minimum?: number;
+  maximum?: number;
+  exclusiveMinimum?: boolean | number;
+  exclusiveMaximum?: boolean | number;
+  minLength?: number;
+  maxLength?: number;
+  minItems?: number;
+  maxItems?: number;
+  itemsType?: string | string[];
+  additionalProps?: "true" | "false" | "schema";
+};
+
+export type FieldDoc = {
+  name: string;
+  humanType: string;
+  description?: string;
+  requiredInAll: boolean;
+};
+
+export const unionVariants = (schema: SchemaObject): SchemaObject[] => {
+  const variants = (schema.oneOf ?? schema.anyOf ?? []) as SchemaObject[];
+
+  // If parent schema has properties that variants don't, merge them
+  // This handles the pattern where anyOf/oneOf is used just for required field combinations
+  if (schema.properties && Object.keys(schema.properties).length > 0) {
+    return variants.map((variant) => {
+      // If variant doesn't define its own properties or type, inherit from parent
+      const shouldInherit =
+        !variant.properties &&
+        !variant.type &&
+        !variant.oneOf &&
+        !variant.anyOf;
+
+      if (shouldInherit) {
+        return {
+          ...variant,
+          type: "object" as const,
+          properties: schema.properties,
+          required: variant.required ?? schema.required,
+        };
+      }
+
+      return variant;
+    });
+  }
+
+  return variants;
+};
+
+export const decideExclusivity = (
+  schema: SchemaObject,
+): "exactly-one" | "at-least-one" => {
+  if (Array.isArray(schema.oneOf)) return "exactly-one";
+
+  const discriminator = schema.discriminator?.propertyName;
+  if (!discriminator) return "at-least-one";
+
+  const variants = unionVariants(schema);
+  const seen = new Set<string>();
+
+  for (const variant of variants) {
+    const prop = variant.properties?.[discriminator];
+
+    const value =
+      prop?.const ??
+      (Array.isArray(prop?.enum) && prop.enum.length === 1
+        ? String(prop.enum[0])
+        : undefined);
+
+    if (value == null || seen.has(String(value))) return "at-least-one";
+    seen.add(String(value));
+  }
+
+  return "exactly-one";
+};
+
+export const labelForVariant = (index: number, variant: SchemaObject) =>
+  variant.title?.trim() || `Variant ${index + 1}`;
+
+export const quickGuards = (variant: SchemaObject, root?: SchemaObject) => {
+  const guards: string[] = [];
+
+  if (variant.type) {
+    guards.push(
+      `type = ${Array.isArray(variant.type) ? variant.type.join("|") : variant.type}`,
+    );
+  }
+
+  const discriminator = root?.discriminator?.propertyName;
+  if (discriminator) {
+    const discriminatorProp = variant.properties?.[discriminator] as
+      | SchemaObject
+      | undefined;
+
+    const discriminatorValue =
+      discriminatorProp?.const ??
+      (Array.isArray(discriminatorProp?.enum) &&
+      discriminatorProp.enum.length === 1
+        ? discriminatorProp.enum[0]
+        : undefined);
+
+    if (discriminatorValue !== undefined) {
+      guards.push(`${discriminator}=${JSON.stringify(discriminatorValue)}`);
+    }
+  }
+
+  const required = (variant.required ?? []).filter((k) => k !== discriminator);
+  if (required.length) {
+    const head = required.slice(0, 3).join(", ");
+    const more = required.length > 3 ? ` +${required.length - 3} more` : "";
+    guards.push(`requires: ${head}${more}`);
+  }
+
+  return guards;
+};

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

@@ -1,49 +1,49 @@
-import {
-  CIRCULAR_REF,
-  SCHEMA_REF_PREFIX,
-} from "../../../oas/graphql/constants.js";
-import type {
-  ArraySchemaObject,
-  SchemaObject,
-} from "../../../oas/parser/index.js";
-
-export const isBasicType = (
-  type: unknown,
-): type is "string" | "number" | "boolean" | "integer" | "null" =>
-  (typeof type === "string" &&
-    ["string", "number", "boolean", "integer", "null"].includes(type)) ||
-  (Array.isArray(type) && type.every(isBasicType));
-
-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"));
-
-export const isComplexType = (value?: SchemaObject) =>
-  value &&
-  ((value.type === "object" &&
-    Object.keys(value.properties ?? {}).length > 0) ||
-    (value.type === "array" &&
-      typeof value.items === "object" &&
-      (!value.items.type || value.items.type === "object")));
-
-export const isCircularRef = (schema: unknown): schema is string =>
-  typeof schema === "string" &&
-  (schema.startsWith(CIRCULAR_REF) || schema.startsWith(SCHEMA_REF_PREFIX));
-
-export const isArrayCircularRef = (
-  schema: SchemaObject,
-): schema is SchemaObject & { items: SchemaObject } =>
-  isArrayType(schema) && "items" in schema && isCircularRef(schema.items);
-
-export const extractCircularRefInfo = (
-  ref?: string | SchemaObject,
-): 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];
-};
+import {
+  CIRCULAR_REF,
+  SCHEMA_REF_PREFIX,
+} from "../../../oas/graphql/constants.js";
+import type {
+  ArraySchemaObject,
+  SchemaObject,
+} from "../../../oas/parser/index.js";
+
+export const isBasicType = (
+  type: unknown,
+): type is "string" | "number" | "boolean" | "integer" | "null" =>
+  (typeof type === "string" &&
+    ["string", "number", "boolean", "integer", "null"].includes(type)) ||
+  (Array.isArray(type) && type.every(isBasicType));
+
+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"));
+
+export const isComplexType = (value?: SchemaObject) =>
+  value &&
+  ((value.type === "object" &&
+    Object.keys(value.properties ?? {}).length > 0) ||
+    (value.type === "array" &&
+      typeof value.items === "object" &&
+      (!value.items.type || value.items.type === "object")));
+
+export const isCircularRef = (schema: unknown): schema is string =>
+  typeof schema === "string" &&
+  (schema.startsWith(CIRCULAR_REF) || schema.startsWith(SCHEMA_REF_PREFIX));
+
+export const isArrayCircularRef = (
+  schema: SchemaObject,
+): schema is SchemaObject & { items: SchemaObject } =>
+  isArrayType(schema) && "items" in schema && isCircularRef(schema.items);
+
+export const extractCircularRefInfo = (
+  ref?: string | SchemaObject,
+): 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/state.ts

@@ -1,36 +1,36 @@
-import { useMemo } from "react";
-import { create } from "zustand";
-import { persist } from "zustand/middleware";
-
-interface SelectedServerState {
-  selectedServer?: string;
-  setSelectedServer: (newServer: string) => void;
-}
-
-export const useSelectedServerStore = create<SelectedServerState>()(
-  persist(
-    (set) => ({
-      selectedServer: undefined,
-      setSelectedServer: (newServer: string) =>
-        set({ selectedServer: newServer }),
-    }),
-    { name: "zudoku-selected-server" },
-  ),
-);
-
-/**
- * Simple wrapper for `useSelectedServerStore` to fall back to first of the provided servers
- */
-export const useSelectedServer = (servers: Array<{ url: string }>) => {
-  const { selectedServer, setSelectedServer } = useSelectedServerStore();
-
-  const finalSelectedServer = useMemo(
-    () =>
-      selectedServer && servers.some((s) => s.url === selectedServer)
-        ? selectedServer
-        : (servers.at(0)?.url ?? ""),
-    [selectedServer, servers],
-  );
-
-  return { selectedServer: finalSelectedServer, setSelectedServer };
-};
+import { useMemo } from "react";
+import { create } from "zustand";
+import { persist } from "zustand/middleware";
+
+interface SelectedServerState {
+  selectedServer?: string;
+  setSelectedServer: (newServer: string) => void;
+}
+
+export const useSelectedServerStore = create<SelectedServerState>()(
+  persist(
+    (set) => ({
+      selectedServer: undefined,
+      setSelectedServer: (newServer: string) =>
+        set({ selectedServer: newServer }),
+    }),
+    { name: "zudoku-selected-server" },
+  ),
+);
+
+/**
+ * Simple wrapper for `useSelectedServerStore` to fall back to first of the provided servers
+ */
+export const useSelectedServer = (servers: Array<{ url: string }>) => {
+  const { selectedServer, setSelectedServer } = useSelectedServerStore();
+
+  const finalSelectedServer = useMemo(
+    () =>
+      selectedServer && servers.some((s) => s.url === selectedServer)
+        ? selectedServer
+        : (servers.at(0)?.url ?? ""),
+    [selectedServer, servers],
+  );
+
+  return { selectedServer: finalSelectedServer, setSelectedServer };
+};

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

@@ -1,54 +1,54 @@
-import type { NavigationItem } from "../../../../config/validators/NavigationSchema.js";
-
-type TagGroup = { name: string; tags: string[] };
-
-type BuildTagCategoriesOptions = {
-  tagCategories: Map<string, NavigationItem>;
-  tagGroups: TagGroup[];
-  expandAllTags?: boolean;
-};
-
-// Merges tags and x-tagGroups with the same name into a single sidebar
-// category (mimics OpenAPI 3.2.0 "Enhanced tags" behaviour).
-export const buildTagCategories = ({
-  tagCategories,
-  tagGroups,
-  expandAllTags,
-}: BuildTagCategoriesOptions): NavigationItem[] => {
-  const consumedTags = new Set<string>();
-
-  const groupedCategories = tagGroups.flatMap<NavigationItem>((group) => {
-    // Use a same-named tag as base so its operations appear first
-    const matchingTag = tagCategories.get(group.name);
-    const base = matchingTag?.type === "category" ? matchingTag : undefined;
-
-    if (base) consumedTags.add(group.name);
-
-    // Exclude group's own name to avoid nesting a tag inside itself
-    const childTags = group.tags.flatMap((name) => {
-      if (name === group.name) return [];
-      const tag = tagCategories.get(name);
-      if (!tag) return [];
-      consumedTags.add(name);
-      return tag;
-    });
-
-    if (!base && childTags.length === 0) return [];
-
-    return {
-      ...base,
-      type: "category",
-      label: base?.label ?? group.name,
-      items: [...(base?.items ?? []), ...childTags],
-      collapsible: base?.collapsible ?? true,
-      collapsed: base?.collapsed ?? !expandAllTags,
-    };
-  });
-
-  // Tags not claimed by any group appear as standalone entries
-  const ungroupedCategories = Array.from(tagCategories.entries())
-    .filter(([name]) => !consumedTags.has(name))
-    .map(([, cat]) => cat);
-
-  return [...groupedCategories, ...ungroupedCategories];
-};
+import type { NavigationItem } from "../../../../config/validators/NavigationSchema.js";
+
+type TagGroup = { name: string; tags: string[] };
+
+type BuildTagCategoriesOptions = {
+  tagCategories: Map<string, NavigationItem>;
+  tagGroups: TagGroup[];
+  expandAllTags?: boolean;
+};
+
+// Merges tags and x-tagGroups with the same name into a single sidebar
+// category (mimics OpenAPI 3.2.0 "Enhanced tags" behaviour).
+export const buildTagCategories = ({
+  tagCategories,
+  tagGroups,
+  expandAllTags,
+}: BuildTagCategoriesOptions): NavigationItem[] => {
+  const consumedTags = new Set<string>();
+
+  const groupedCategories = tagGroups.flatMap<NavigationItem>((group) => {
+    // Use a same-named tag as base so its operations appear first
+    const matchingTag = tagCategories.get(group.name);
+    const base = matchingTag?.type === "category" ? matchingTag : undefined;
+
+    if (base) consumedTags.add(group.name);
+
+    // Exclude group's own name to avoid nesting a tag inside itself
+    const childTags = group.tags.flatMap((name) => {
+      if (name === group.name) return [];
+      const tag = tagCategories.get(name);
+      if (!tag) return [];
+      consumedTags.add(name);
+      return tag;
+    });
+
+    if (!base && childTags.length === 0) return [];
+
+    return {
+      ...base,
+      type: "category",
+      label: base?.label ?? group.name,
+      items: [...(base?.items ?? []), ...childTags],
+      collapsible: base?.collapsible ?? true,
+      collapsed: base?.collapsed ?? !expandAllTags,
+    };
+  });
+
+  // Tags not claimed by any group appear as standalone entries
+  const ungroupedCategories = Array.from(tagCategories.entries())
+    .filter(([name]) => !consumedTags.has(name))
+    .map(([, cat]) => cat);
+
+  return [...groupedCategories, ...ungroupedCategories];
+};