@aravindc26/velu 0.11.0 → 0.11.3

package/src/validate.ts

@@ -3,6 +3,16 @@ import addFormats from "ajv-formats";
 import { readFileSync, existsSync } from "node:fs";
 import { resolve, join } from "node:path";
 import { normalizeConfigNavigation } from "./navigation-normalize.js";
+const PRIMARY_CONFIG_NAME = "docs.json";
+const LEGACY_CONFIG_NAME = "velu.json";
+
+function resolveConfigPath(docsDir: string): string | null {
+  const primary = join(docsDir, PRIMARY_CONFIG_NAME);
+  if (existsSync(primary)) return primary;
+  const legacy = join(docsDir, LEGACY_CONFIG_NAME);
+  if (existsSync(legacy)) return legacy;
+  return null;
+}
 
 interface VeluSeparator {
   separator: string;
@@ -12,12 +22,17 @@ interface VeluLink {
   href: string;
   label: string;
   icon?: string;
+  iconType?: string;
 }
 
 interface VeluAnchor {
   anchor: string;
   href?: string;
   icon?: string;
+  iconType?: string;
+  version?: string;
+  openapi?: VeluOpenApiSource;
+  asyncapi?: VeluOpenApiSource;
   color?: {
     light: string;
     dark: string;
@@ -30,13 +45,18 @@ interface VeluGlobalTab {
   tab: string;
   href: string;
   icon?: string;
+  iconType?: string;
 }
 
 interface VeluGroup {
   group: string;
   slug?: string;
   icon?: string;
+  iconType?: string;
   tag?: string;
+  version?: string;
+  openapi?: VeluOpenApiSource;
+  asyncapi?: VeluOpenApiSource;
   expanded?: boolean;
   description?: string;
   hidden?: boolean;
@@ -46,6 +66,9 @@ interface VeluGroup {
 interface VeluMenuItem {
   item: string;
   icon?: string;
+  iconType?: string;
+  openapi?: VeluOpenApiSource;
+  asyncapi?: VeluOpenApiSource;
   groups?: VeluGroup[];
   pages?: (string | VeluSeparator | VeluLink)[];
 }
@@ -54,7 +77,11 @@ interface VeluTab {
   tab: string;
   slug?: string;
   icon?: string;
+  iconType?: string;
+  version?: string;
   href?: string;
+  openapi?: VeluOpenApiSource;
+  asyncapi?: VeluOpenApiSource;
   pages?: (string | VeluSeparator | VeluLink)[];
   groups?: VeluGroup[];
   menu?: VeluMenuItem[];
@@ -62,28 +89,65 @@ interface VeluTab {
 
 interface VeluLanguageNav {
   language: string;
+  openapi?: VeluOpenApiSource;
+  asyncapi?: VeluOpenApiSource;
   tabs: VeluTab[];
 }
 
 interface VeluProductNav {
   product: string;
   icon?: string;
+  iconType?: string;
+  openapi?: VeluOpenApiSource;
+  asyncapi?: VeluOpenApiSource;
   tabs?: VeluTab[];
   pages?: (string | VeluSeparator | VeluLink)[];
 }
 
 interface VeluVersionNav {
   version: string;
+  openapi?: VeluOpenApiSource;
+  asyncapi?: VeluOpenApiSource;
   tabs: VeluTab[];
 }
 
+type VeluOpenApiSource = string | string[] | Record<string, unknown>;
+
 interface VeluConfig {
   $schema?: string;
+  icons?: {
+    library?: "fontawesome" | "lucide" | "tabler";
+  };
   theme?: string;
   colors?: { primary?: string; light?: string; dark?: string };
   appearance?: "system" | "light" | "dark";
   styling?: { codeblocks?: { theme?: string | { light: string; dark: string } } };
+  openapi?: VeluOpenApiSource;
+  asyncapi?: VeluOpenApiSource;
+  api?: {
+    baseUrl?: string;
+    playground?: {
+      mode?: string;
+      display?: string;
+      proxy?: boolean;
+    };
+    examples?: {
+      languages?: string[];
+      defaults?: "required" | "all";
+      prefill?: boolean;
+      autogenerate?: boolean;
+    };
+    mdx?: {
+      server?: string;
+      auth?: {
+        method?: "bearer" | "basic" | "key" | "none";
+        name?: string;
+      };
+    };
+  };
   navigation: {
+    openapi?: VeluOpenApiSource;
+    asyncapi?: VeluOpenApiSource;
     tabs?: VeluTab[];
     languages?: VeluLanguageNav[];
     products?: VeluProductNav[];
@@ -96,6 +160,49 @@ interface VeluConfig {
   };
 }
 
+const HTTP_METHODS = new Set([
+  "GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS", "HEAD", "TRACE", "CONNECT", "WEBHOOK",
+]);
+
+function isOpenApiOperationReference(value: string): boolean {
+  const trimmed = value.trim();
+  if (!trimmed) return false;
+  const withSpec = trimmed.match(/^(\S+)\s+([A-Za-z]+)\s+(.+)$/);
+  if (withSpec) {
+    const method = withSpec[2].toUpperCase();
+    const endpoint = withSpec[3].trim();
+    if (!HTTP_METHODS.has(method)) return false;
+    if (method === "WEBHOOK") return endpoint.length > 0;
+    return endpoint.startsWith("/");
+  }
+  const noSpec = trimmed.match(/^([A-Za-z]+)\s+(.+)$/);
+  if (!noSpec) return false;
+  const method = noSpec[1].toUpperCase();
+  const endpoint = noSpec[2].trim();
+  if (!HTTP_METHODS.has(method)) return false;
+  if (method === "WEBHOOK") return endpoint.length > 0;
+  return endpoint.startsWith("/");
+}
+
+function isAsyncApiChannelReference(value: string): boolean {
+  const trimmed = value.trim();
+  if (!trimmed) return false;
+  const withSpec = trimmed.match(/^(\S+)\s+(.+)$/);
+  if (!withSpec) return false;
+  const first = withSpec[1].trim();
+  const maybeMethod = first.toUpperCase();
+  if (HTTP_METHODS.has(maybeMethod)) return false;
+  const looksLikeSpec =
+    first.startsWith('/') ||
+    first.startsWith('./') ||
+    first.startsWith('../') ||
+    /^https?:\/\//i.test(first) ||
+    first.endsWith('.json') ||
+    first.endsWith('.yaml') ||
+    first.endsWith('.yml');
+  return looksLikeSpec && withSpec[2].trim().length > 0;
+}
+
 function loadJson(filePath: string): unknown {
   const raw = readFileSync(filePath, "utf-8");
   return JSON.parse(raw);
@@ -150,9 +257,12 @@ function collectPages(config: VeluConfig): string[] {
 function validateVeluConfig(docsDir: string, schemaPath: string): { valid: boolean; errors: string[] } {
   const errors: string[] = [];
 
-  const configPath = join(docsDir, "velu.json");
-  if (!existsSync(configPath)) {
-    return { valid: false, errors: [`velu.json not found at ${configPath}`] };
+  const configPath = resolveConfigPath(docsDir);
+  if (!configPath) {
+    return {
+      valid: false,
+      errors: [`docs.json or velu.json not found at ${join(docsDir, PRIMARY_CONFIG_NAME)}`],
+    };
   }
 
   if (!existsSync(schemaPath)) {
@@ -176,12 +286,15 @@ function validateVeluConfig(docsDir: string, schemaPath: string): { valid: boole
 
   const config = normalizeConfigNavigation(rawConfig);
 
-  // Validate that all referenced .md files exist
+  // Validate that all referenced page files exist (.mdx or .md)
   const pages = collectPages(config);
   for (const page of pages) {
+    if (isOpenApiOperationReference(page)) continue;
+    if (isAsyncApiChannelReference(page)) continue;
+    const mdxPath = join(docsDir, `${page}.mdx`);
     const mdPath = join(docsDir, `${page}.md`);
-    if (!existsSync(mdPath)) {
-      errors.push(`Missing page: ${page}.md (expected at ${mdPath})`);
+    if (!existsSync(mdxPath) && !existsSync(mdPath)) {
+      errors.push(`Missing page: ${page}.md or ${page}.mdx (expected at ${mdPath})`);
     }
   }
 

package/src/engine/app/(docs)/[[...slug]]/layout.tsx

@@ -1,87 +0,0 @@
-import type { ReactNode } from 'react';
-import { DocsLayout } from 'fumadocs-ui/layouts/docs';
-import { baseOptions } from '@/lib/layout.shared';
-import { source } from '@/lib/source';
-import { getLanguages, getVersionOptions, getProductOptions, type VeluVersionOption, type VeluProductOption } from '@/lib/velu';
-import { SidebarLinks } from '@/components/sidebar-links';
-import { ProductSwitcher } from '@/components/product-switcher';
-
-interface LayoutParams {
-  slug?: string[];
-}
-
-interface SlugLayoutProps {
-  children: ReactNode;
-  params: Promise<LayoutParams>;
-}
-
-function resolveLocale(slugInput: string[] | undefined): string {
-  const languages = getLanguages();
-  const defaultLanguage = languages[0] ?? 'en';
-  const slug = slugInput ?? [];
-  const firstSeg = slug[0];
-
-  return languages.includes(firstSeg ?? '') ? firstSeg! : defaultLanguage;
-}
-
-function resolveCurrentVersion(slugInput: string[] | undefined, versions: VeluVersionOption[]): VeluVersionOption | undefined {
-  if (versions.length === 0) return undefined;
-  const firstSeg = (slugInput ?? [])[0] ?? '';
-  return versions.find((v) => v.slug === firstSeg) ?? versions.find((v) => v.isDefault) ?? versions[0];
-}
-
-function filterTreeBySlugPrefix<T extends { children?: unknown[] }>(tree: T, prefix?: string): T {
-  if (!prefix) return tree;
-
-  const children = Array.isArray(tree.children) ? tree.children : [];
-
-  const filtered = children.filter((node) => {
-    if (typeof node !== 'object' || node === null) return false;
-    const entry = node as { url?: unknown; path?: unknown; $ref?: { metaFile?: unknown; file?: unknown } };
-    const candidates = [entry.url, entry.path, entry.$ref?.metaFile, entry.$ref?.file]
-      .filter((value): value is string => typeof value === 'string');
-    return candidates.some((value) => value.includes(`${prefix}/`));
-  });
-
-  if (filtered.length === 0) return tree;
-  return { ...tree, children: filtered } as T;
-}
-
-function resolveCurrentProduct(slugInput: string[] | undefined, products: VeluProductOption[]): VeluProductOption | undefined {
-  if (products.length === 0) return undefined;
-  const firstSeg = (slugInput ?? [])[0] ?? '';
-  return products.find((p) => p.slug === firstSeg) ?? products[0];
-}
-
-export default async function SlugLayout({ children, params }: SlugLayoutProps) {
-  const resolvedParams = await params;
-  const locale = resolveLocale(resolvedParams.slug);
-  const versions = getVersionOptions();
-  const products = getProductOptions();
-  const currentVersion = resolveCurrentVersion(resolvedParams.slug, versions);
-  const currentProduct = resolveCurrentProduct(resolvedParams.slug, products);
-
-  const activePrefix = currentVersion?.slug ?? currentProduct?.slug;
-  const tree = filterTreeBySlugPrefix(source.getPageTree(locale), activePrefix);
-
-  return (
-    <DocsLayout
-      tree={tree}
-      sidebar={{
-        collapsible: false,
-        banner: products.length > 1 ? (
-          <div className="velu-sidebar-banner">
-            <ProductSwitcher products={products} />
-          </div>
-        ) : undefined,
-        footer: <SidebarLinks />,
-      }}
-      {...baseOptions()}
-      themeSwitch={{ enabled: false }}
-    >
-      {children}
-    </DocsLayout>
-  );
-}
-
-export { generateStaticParams } from './page';

package/src/engine/app/(docs)/[[...slug]]/page.tsx

@@ -1,146 +0,0 @@
-import type { Metadata } from 'next';
-import { notFound } from 'next/navigation';
-import { createRelativeLink } from 'fumadocs-ui/mdx';
-import {
-  DocsBody,
-  DocsDescription,
-  DocsPage,
-  DocsTitle,
-} from 'fumadocs-ui/layouts/docs/page';
-import { getMDXComponents } from '@/mdx-components';
-import { source } from '@/lib/source';
-import { getLanguages, getVersionOptions, getProductOptions } from '@/lib/velu';
-import { CopyPageButton } from '@/components/copy-page';
-
-interface RouteParams {
-  slug?: string[];
-}
-
-interface PageProps {
-  params: Promise<RouteParams>;
-}
-
-function resolveLocaleSlug(slugInput: string[] | undefined) {
-  const languages = getLanguages();
-  const defaultLanguage = languages[0] ?? 'en';
-  const slug = slugInput ?? [];
-  const firstSeg = slug[0];
-  const hasLocalePrefix = languages.includes(firstSeg ?? '');
-
-  return {
-    defaultLanguage,
-    locale: hasLocalePrefix ? firstSeg! : defaultLanguage,
-    pageSlug: hasLocalePrefix ? slug.slice(1) : slug,
-  };
-}
-
-function resolveContextFromSlug(slugInput: string[] | undefined) {
-  const languages = getLanguages();
-  const versions = getVersionOptions();
-  const products = getProductOptions();
-  const slug = slugInput ?? [];
-  
-  // Check for language prefix
-  const firstSeg = slug[0];
-  const hasLocalePrefix = languages.includes(firstSeg ?? '');
-  const locale = hasLocalePrefix ? firstSeg! : (languages[0] ?? 'en');
-  const remainingSlug = hasLocalePrefix ? slug.slice(1) : slug;
-  
-  // Check for version/product in remaining slug
-  const contextSeg = remainingSlug[0] ?? '';
-  const version = versions.find((v) => v.slug === contextSeg);
-  const product = products.find((p) => p.slug === contextSeg);
-  
-  return {
-    locale,
-    version: version?.slug,
-    product: product?.slug,
-  };
-}
-
-export default async function Page({ params }: PageProps) {
-  const resolvedParams = await params;
-  const { locale, pageSlug } = resolveLocaleSlug(resolvedParams.slug);
-  const { locale: filterLocale, version, product } = resolveContextFromSlug(resolvedParams.slug);
-  const hasI18n = getLanguages().length > 1;
-
-  const page = hasI18n ? source.getPage(pageSlug, locale) : source.getPage(pageSlug);
-
-  if (!page) notFound();
-
-  const MDX = page.data.body;
-
-  // Build pagefind filter attributes
-  const metaAttrs: string[] = [`title:${page.data.title}`];
-  const filterAttrs: string[] = [];
-  if (hasI18n) {
-    metaAttrs.push(`language:${filterLocale}`);
-    filterAttrs.push(`language:${filterLocale}`);
-  }
-  if (version) {
-    metaAttrs.push(`version:${version}`);
-    filterAttrs.push(`version:${version}`);
-  }
-  if (product) {
-    metaAttrs.push(`product:${product}`);
-    filterAttrs.push(`product:${product}`);
-  }
-
-  return (
-    <DocsPage toc={page.data.toc} full={page.data.full}>
-      <div
-        data-pagefind-body
-        data-pagefind-meta={metaAttrs.join(',')}
-        data-pagefind-filter={filterAttrs.length > 0 ? filterAttrs.join(',') : undefined}
-      >
-        <div className="velu-title-row">
-          <DocsTitle>{page.data.title}</DocsTitle>
-          <CopyPageButton />
-        </div>
-        {page.data.description ? <DocsDescription>{page.data.description}</DocsDescription> : null}
-        <DocsBody>
-          <MDX
-            components={getMDXComponents({
-              a: createRelativeLink(source, page),
-            })}
-          />
-        </DocsBody>
-      </div>
-      <footer className="velu-footer">
-        Powered by <a href="https://getvelu.com" target="_blank" rel="noopener noreferrer">Velu</a>
-      </footer>
-    </DocsPage>
-  );
-}
-
-export async function generateStaticParams() {
-  const generated = source.generateParams('slug') as Array<{ slug?: string[] }>;
-  const seen = new Set<string>();
-
-  const nonRoot = generated.filter((entry) => {
-    const slug = entry.slug ?? [];
-    if (slug.length === 0) return false;
-    const key = slug.join('/');
-    if (seen.has(key)) return false;
-    seen.add(key);
-    return true;
-  });
-
-  // Include root variants for optional catch-all [[...slug]] in export mode.
-  return [{}, { slug: undefined }, { slug: [] }, ...nonRoot];
-}
-
-export async function generateMetadata({ params }: PageProps): Promise<Metadata> {
-  const resolvedParams = await params;
-  const { locale, pageSlug } = resolveLocaleSlug(resolvedParams.slug);
-  const hasI18n = getLanguages().length > 1;
-
-  const page = hasI18n ? source.getPage(pageSlug, locale) : source.getPage(pageSlug);
-
-  if (!page) notFound();
-
-  return {
-    title: page.data.title,
-    description: page.data.description,
-  };
-}