@lukoweb/apitogo 0.1.54 → 0.1.55

package/dist/flat-config.d.ts

@@ -137,6 +137,7 @@ export interface FlatZudokuConfig {
   }
   site?: {
     title?: string
+    showTitleInHeader?: boolean
     logoUrl?: string
     dir?: ("ltr" | "rtl")
     logo?: _Schema0
@@ -533,13 +534,56 @@ export interface _Schema21 {
     title?: string
     subtitle?: string
     description?: string
+    badge?: string
+    highlights?: string[]
+    codeExample?: {
+      filename?: string
+      language?: string
+      code: string
+    }
   }
   features?: {
     title: string
     description: string
+    icon?: string
   }[]
   primaryAction?: _Schema22
   secondaryAction?: _Schema22
+  ticker?: {
+    enabled?: boolean
+    items?: {
+      label: string
+      value: string
+      change?: string
+    }[]
+  }
+  trust?: {
+    enabled?: boolean
+    title?: string
+    logos?: string[]
+  }
+  apiShowcase?: {
+    enabled?: boolean
+    title?: string
+    subtitle?: string
+    browseAllHref?: string
+    browseAllLabel?: string
+    autoFromOpenApi?: boolean
+    items?: {
+      name: string
+      path: string
+      icon?: string
+      latency?: string
+      summary?: string
+    }[]
+  }
+  pricingCta?: {
+    enabled?: boolean
+    title?: string
+    description?: string
+    primaryAction?: _Schema22
+    secondaryAction?: _Schema22
+  }
   showPoweredBy?: boolean
 }
 export interface _Schema22 {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lukoweb/apitogo",
-  "version": "0.1.54",
+  "version": "0.1.55",
   "type": "module",
   "sideEffects": [
     "**/*.css",

package/src/app/main.css

@@ -102,8 +102,8 @@
 
 @layer base {
   :root {
-    --top-header-height: 65px;
-    --top-nav-height: 50px;
+    --top-header-height: 64px;
+    --top-nav-height: 0px;
     --banner-height: 35px;
     --header-height: calc(
       var(--top-header-height) + var(--top-nav-height) + var(--banner-height)

package/src/config/apitogo-config-core.ts

@@ -12,6 +12,7 @@ const DERIVED_MANIFEST_KEYS = [
   "backend",
   "gateway",
   "projectId",
+  "landing",
 ] as const;
 
 const SITE_CONFIG_KEYS = [
@@ -542,6 +543,18 @@ export function deriveManifestFields(
       }
       continue;
     }
+    if (key === "landing") {
+      const modules = asRecord(normalized.modules);
+      const landing = asRecord(modules?.landing);
+      if (landing?.content || landing?.enabled !== undefined) {
+        manifest.landing = {
+          enabled:
+            typeof landing.enabled === "boolean" ? landing.enabled : undefined,
+          content: landing.content,
+        };
+      }
+      continue;
+    }
     if (normalized[key] !== undefined) {
       manifest[key] = normalized[key];
     }

package/src/config/apitogo-config-loader.browser.ts

@@ -0,0 +1,17 @@
+import type {
+  ApitogoJsonConfig,
+  AuthenticationSecrets,
+} from "./apitogo-config-core.js";
+
+/** Browser stub — JSON config is embedded by the Vite config plugin on the client. */
+export function loadApitogoConfig(_rootDir?: string): ApitogoJsonConfig {
+  return {};
+}
+
+export function readAuthenticationSecrets(): AuthenticationSecrets {
+  return {};
+}
+
+export function apitogoConfigPath(rootDir: string): string {
+  return rootDir;
+}

package/src/config/build-apitogo-config.ts

@@ -11,6 +11,13 @@ type BuildApitogoConfigOptions = Partial<ApitogoConfig> &
     plugins?: ApitogoPlugin[];
   };
 
+function mergeOptionalRecord<T extends Record<string, unknown>>(
+  ...records: Array<T | undefined>
+): T | undefined {
+  const merged = Object.assign({}, ...records.filter(Boolean)) as T;
+  return Object.keys(merged).length > 0 ? merged : undefined;
+}
+
 export function buildApitogoConfig({
   plugins,
   plans: _legacyPlans,
@@ -24,14 +31,16 @@ export function buildApitogoConfig({
   const { plans: _rootPlans, ...restOverrides } =
     jsonOverrides as ApitogoJsonConfig;
 
+  const authentication = mergeOptionalRecord(
+    siteConfig.authentication as ApitogoConfig["authentication"],
+    jsonOverrides.authentication as ApitogoConfig["authentication"],
+  );
+
   return {
     ...siteConfig,
     ...restOverrides,
     plugins,
-    authentication: {
-      ...(siteConfig.authentication as ApitogoConfig["authentication"]),
-      ...jsonOverrides.authentication,
-    },
+    ...(authentication ? { authentication } : {}),
     site: {
       ...(siteConfig.site as ApitogoConfig["site"]),
       ...jsonOverrides.site,

package/src/config/landing-manifest.ts

@@ -0,0 +1,11 @@
+import { z } from "zod";
+import { LandingContentSchema } from "./validators/ModulesSchema.js";
+
+export const LandingManifestContentSchema = LandingContentSchema;
+
+export type LandingManifestContent = z.infer<typeof LandingContentSchema>;
+
+export type LandingManifestInput = {
+  enabled?: boolean;
+  content?: LandingManifestContent;
+};

package/src/config/landing-openapi-showcase.ts

@@ -0,0 +1,115 @@
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import type { LandingApiShowcaseItemConfig } from "./validators/ModulesSchema.js";
+import type { ZudokuConfig } from "./validators/ZudokuConfig.js";
+
+const HTTP_METHODS = [
+  "get",
+  "post",
+  "put",
+  "patch",
+  "delete",
+  "head",
+  "options",
+] as const;
+
+type OpenApiDocument = {
+  paths?: Record<
+    string,
+    Partial<Record<(typeof HTTP_METHODS)[number], { summary?: string }>>
+  >;
+};
+
+function readOpenApiDocument(
+  rootDir: string,
+  openApiPath: string,
+): OpenApiDocument | null {
+  try {
+    const absolutePath = path.isAbsolute(openApiPath)
+      ? openApiPath
+      : path.resolve(rootDir, openApiPath);
+    const raw = readFileSync(absolutePath, "utf8");
+    return JSON.parse(raw) as OpenApiDocument;
+  } catch {
+    return null;
+  }
+}
+
+function resolveOpenApiPath(config: ZudokuConfig): string | undefined {
+  const backend = (config as { backend?: { openApiPath?: string } }).backend;
+  if (backend?.openApiPath) {
+    return backend.openApiPath;
+  }
+
+  const apis = config.apis;
+  if (!apis) {
+    return undefined;
+  }
+
+  const entries = Array.isArray(apis) ? apis : [apis];
+  for (const entry of entries) {
+    if (typeof entry === "object" && entry !== null && "type" in entry) {
+      const api = entry as { type?: string; input?: string };
+      if (api.type === "file" && typeof api.input === "string") {
+        return api.input;
+      }
+    }
+  }
+
+  return undefined;
+}
+
+export function extractApiShowcaseItemsFromOpenApi(
+  config: ZudokuConfig,
+  rootDir: string,
+  limit = 8,
+): LandingApiShowcaseItemConfig[] {
+  const openApiPath = resolveOpenApiPath(config);
+  if (!openApiPath) {
+    return [];
+  }
+
+  const document = readOpenApiDocument(rootDir, openApiPath);
+  if (!document?.paths) {
+    return [];
+  }
+
+  const items: LandingApiShowcaseItemConfig[] = [];
+
+  for (const [routePath, methods] of Object.entries(document.paths)) {
+    for (const method of HTTP_METHODS) {
+      const operation = methods?.[method];
+      if (!operation) {
+        continue;
+      }
+
+      items.push({
+        name: operation.summary ?? `${method.toUpperCase()} ${routePath}`,
+        path: routePath,
+        summary: operation.summary,
+      });
+
+      if (items.length >= limit) {
+        return items;
+      }
+    }
+  }
+
+  return items;
+}
+
+export function enrichResolvedLandingApiShowcase(
+  config: ZudokuConfig,
+  resolved: { landing: { content: { apiShowcase?: { autoFromOpenApi?: boolean; items?: LandingApiShowcaseItemConfig[] } } } },
+  rootDir: string,
+): void {
+  const showcase = resolved.landing.content.apiShowcase;
+  if (
+    !showcase?.autoFromOpenApi ||
+    (showcase.items && showcase.items.length > 0)
+  ) {
+    return;
+  }
+
+  showcase.items = extractApiShowcaseItemsFromOpenApi(config, rootDir);
+}

package/src/config/loader.ts

@@ -18,6 +18,7 @@ import {
   loadApitogoConfig,
   readPlanCatalogItems,
 } from "./apitogo-config-loader.js";
+import { buildApitogoConfig } from "./build-apitogo-config.js";
 import { fileExists } from "./file-exists.js";
 import {
   isAuthenticationEnabled,
@@ -117,7 +118,18 @@ async function loadZudokuConfigWithMeta(
     },
   });
 
-  const config = module.default;
+  const importedConfig = module.default;
+
+  let config: ZudokuConfig;
+  try {
+    const fileConfig = loadApitogoConfig(rootDir);
+    config = buildApitogoConfig({
+      ...fileConfig,
+      plugins: importedConfig.plugins,
+    });
+  } catch {
+    config = importedConfig;
+  }
 
   validateConfig(config, configPath);
 
@@ -130,7 +142,7 @@ async function loadZudokuConfigWithMeta(
       dependencies,
       configPath,
     },
-    __resolvedModules: resolveModulesConfig(config),
+    __resolvedModules: resolveModulesConfig(config, { rootDir }),
   };
 
   return configWithMetadata;
@@ -288,7 +300,9 @@ export async function loadZudokuConfig(
         ...transformedConfig.__meta,
         ...configWithManifestMeta.__meta,
       },
-      __resolvedModules: resolveModulesConfig(transformedConfig),
+      __resolvedModules: resolveModulesConfig(transformedConfig, {
+        rootDir: transformedConfig.__meta.rootDir,
+      }),
     };
 
     if (!process.env.APITOGO_JSON_ONLY) {

package/src/config/local-manifest.ts

@@ -1,4 +1,4 @@
-import { access, readFile } from "node:fs/promises";
+import { readFile } from "node:fs/promises";
 import path from "node:path";
 import { z } from "zod";
 import {
@@ -8,6 +8,10 @@ import {
   loadApitogoConfig,
   readPlanCatalogItems,
 } from "./apitogo-config-loader.js";
+import {
+  type LandingManifestInput,
+  LandingManifestContentSchema,
+} from "./landing-manifest.js";
 
 /** @deprecated Legacy manifest filenames — apitogo.config.json is the only supported source. */
 export const APITOGO_MANIFEST_BASE_FILENAME = "apitogo.json";
@@ -102,12 +106,19 @@ export const DevPortalLocalManifestSchema = z.object({
     })
     .optional(),
   projectId: z.string().optional(),
+  landing: z
+    .object({
+      enabled: z.boolean().optional(),
+      content: LandingManifestContentSchema,
+    })
+    .optional(),
 });
 
 export type ManifestPlanInput = z.infer<typeof ManifestPlanInputSchema>;
 export type DevPortalLocalManifest = z.infer<
   typeof DevPortalLocalManifestSchema
 >;
+export type { LandingManifestInput };
 
 export type DevPortalPreviewPlan = {
   sku: string;
@@ -213,6 +224,105 @@ export function mergePlansBySku(
   return Array.from(bySku.values());
 }
 
+export function mergeLandingContent(
+  existing: LandingManifestInput["content"] | undefined,
+  patch: LandingManifestInput["content"] | undefined,
+): LandingManifestInput["content"] | undefined {
+  if (!patch) {
+    return existing;
+  }
+  if (!existing) {
+    return patch;
+  }
+
+  const merged = { ...existing, ...patch };
+
+  if (patch.hero) {
+    merged.hero = { ...existing.hero, ...patch.hero };
+    if (patch.hero.codeExample) {
+      merged.hero = {
+        ...merged.hero,
+        codeExample: {
+          ...existing.hero?.codeExample,
+          ...patch.hero.codeExample,
+        },
+      };
+    }
+  }
+
+  if (patch.features) {
+    const byTitle = new Map(
+      (existing.features ?? []).map((feature) => [feature.title, feature]),
+    );
+    for (const feature of patch.features) {
+      const prior = byTitle.get(feature.title);
+      byTitle.set(feature.title, prior ? { ...prior, ...feature } : feature);
+    }
+    merged.features = Array.from(byTitle.values());
+  }
+
+  if (patch.ticker) {
+    merged.ticker = { ...existing.ticker, ...patch.ticker };
+    if (patch.ticker.items) {
+      merged.ticker.items = patch.ticker.items;
+    }
+  }
+
+  if (patch.trust) {
+    merged.trust = { ...existing.trust, ...patch.trust };
+    if (patch.trust.logos) {
+      merged.trust.logos = patch.trust.logos;
+    }
+  }
+
+  if (patch.apiShowcase) {
+    merged.apiShowcase = { ...existing.apiShowcase, ...patch.apiShowcase };
+    if (patch.apiShowcase.items) {
+      const byPath = new Map(
+        (existing.apiShowcase?.items ?? []).map((item) => [item.path, item]),
+      );
+      for (const item of patch.apiShowcase.items) {
+        const prior = byPath.get(item.path);
+        byPath.set(item.path, prior ? { ...prior, ...item } : item);
+      }
+      merged.apiShowcase.items = Array.from(byPath.values());
+    }
+  }
+
+  if (patch.pricingCta) {
+    merged.pricingCta = { ...existing.pricingCta, ...patch.pricingCta };
+  }
+
+  if (patch.primaryAction) {
+    merged.primaryAction = { ...existing.primaryAction, ...patch.primaryAction };
+  }
+  if (patch.secondaryAction) {
+    merged.secondaryAction = {
+      ...existing.secondaryAction,
+      ...patch.secondaryAction,
+    };
+  }
+
+  return merged;
+}
+
+export function mergeLandingManifest(
+  existing: LandingManifestInput | undefined,
+  patch: LandingManifestInput | undefined,
+): LandingManifestInput | undefined {
+  if (!patch) {
+    return existing;
+  }
+  if (!existing) {
+    return patch;
+  }
+
+  return {
+    enabled: patch.enabled ?? existing.enabled,
+    content: mergeLandingContent(existing.content, patch.content),
+  };
+}
+
 export function mergeManifest(
   base: DevPortalLocalManifest,
   override: DevPortalLocalManifest,
@@ -240,6 +350,9 @@ export function mergeManifest(
   if (override.plans) {
     merged.plans = mergePlansBySku(base.plans, override.plans);
   }
+  if (override.landing) {
+    merged.landing = mergeLandingManifest(base.landing, override.landing);
+  }
 
   return merged;
 }
@@ -277,15 +390,6 @@ export function parseLocalManifestJson(
   }
 }
 
-async function fileExists(filePath: string): Promise<boolean> {
-  try {
-    await access(filePath);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
 export async function readManifestFile(
   rootDir: string,
   filename: string,

package/src/config/resolve-modules.ts

@@ -57,7 +57,7 @@ export const resolveLandingContent = (
   const siteTitle =
     config.metadata?.applicationName ?? config.site?.title ?? "APIToGo";
 
-  return {
+  const resolved: ResolvedLandingContent = {
     hero: {
       title: content?.hero?.title ?? siteTitle,
       subtitle: content?.hero?.subtitle ?? "Developer portal",
@@ -65,6 +65,9 @@ export const resolveLandingContent = (
         content?.hero?.description ??
         config.metadata?.description ??
         "Ship beautiful API documentation and developer experiences with APIToGo.",
+      badge: content?.hero?.badge,
+      highlights: content?.hero?.highlights,
+      codeExample: content?.hero?.codeExample,
     },
     features: content?.features ?? DEFAULT_LANDING_FEATURES,
     primaryAction: content?.primaryAction ?? {
@@ -77,6 +80,24 @@ export const resolveLandingContent = (
     },
     showPoweredBy: content?.showPoweredBy,
   };
+
+  if (content?.ticker && content.ticker.enabled !== false) {
+    resolved.ticker = content.ticker;
+  }
+
+  if (content?.trust && content.trust.enabled !== false) {
+    resolved.trust = content.trust;
+  }
+
+  if (content?.apiShowcase && content.apiShowcase.enabled !== false) {
+    resolved.apiShowcase = content.apiShowcase;
+  }
+
+  if (content?.pricingCta && content.pricingCta.enabled !== false) {
+    resolved.pricingCta = content.pricingCta;
+  }
+
+  return resolved;
 };
 
 const DEFAULT_DASHBOARD_QUICK_LINKS: ResolvedDashboardContent["quickLinks"] = [

package/src/config/validators/ModulesSchema.ts

@@ -44,13 +44,76 @@ export const LandingLinkSchema = z.object({
 export const LandingFeatureSchema = z.object({
   title: z.string(),
   description: z.string(),
+  icon: z.string().optional(),
 });
 
+export const LandingCodeExampleSchema = z
+  .object({
+    filename: z.string().optional(),
+    language: z.string().optional(),
+    code: z.string(),
+  })
+  .optional();
+
 export const LandingHeroSchema = z
   .object({
     title: z.string().optional(),
     subtitle: z.string().optional(),
     description: z.string().optional(),
+    badge: z.string().optional(),
+    highlights: z.array(z.string()).optional(),
+    codeExample: LandingCodeExampleSchema,
+  })
+  .optional();
+
+export const LandingTickerItemSchema = z.object({
+  label: z.string(),
+  value: z.string(),
+  change: z.string().optional(),
+});
+
+export const LandingTickerSchema = z
+  .object({
+    enabled: z.boolean().optional(),
+    items: z.array(LandingTickerItemSchema).optional(),
+  })
+  .optional();
+
+export const LandingTrustSchema = z
+  .object({
+    enabled: z.boolean().optional(),
+    title: z.string().optional(),
+    logos: z.array(z.string()).optional(),
+  })
+  .optional();
+
+export const LandingApiShowcaseItemSchema = z.object({
+  name: z.string(),
+  path: z.string(),
+  icon: z.string().optional(),
+  latency: z.string().optional(),
+  summary: z.string().optional(),
+});
+
+export const LandingApiShowcaseSchema = z
+  .object({
+    enabled: z.boolean().optional(),
+    title: z.string().optional(),
+    subtitle: z.string().optional(),
+    browseAllHref: z.string().optional(),
+    browseAllLabel: z.string().optional(),
+    autoFromOpenApi: z.boolean().optional(),
+    items: z.array(LandingApiShowcaseItemSchema).optional(),
+  })
+  .optional();
+
+export const LandingPricingCtaSchema = z
+  .object({
+    enabled: z.boolean().optional(),
+    title: z.string().optional(),
+    description: z.string().optional(),
+    primaryAction: LandingLinkSchema.optional(),
+    secondaryAction: LandingLinkSchema.optional(),
   })
   .optional();
 
@@ -60,6 +123,10 @@ export const LandingContentSchema = z
     features: z.array(LandingFeatureSchema).optional(),
     primaryAction: LandingLinkSchema.optional(),
     secondaryAction: LandingLinkSchema.optional(),
+    ticker: LandingTickerSchema,
+    trust: LandingTrustSchema,
+    apiShowcase: LandingApiShowcaseSchema,
+    pricingCta: LandingPricingCtaSchema,
     showPoweredBy: z.boolean().optional(),
   })
   .optional();
@@ -246,15 +313,32 @@ export type ProfileContentConfig = z.infer<typeof ProfileContentSchema>;
 export type PlansContentConfig = z.infer<typeof PlansContentSchema>;
 export type PlanTierConfig = z.infer<typeof PlanTierSchema>;
 
+export type LandingCodeExampleConfig = z.infer<typeof LandingCodeExampleSchema>;
+export type LandingTickerItemConfig = z.infer<typeof LandingTickerItemSchema>;
+export type LandingTickerConfig = z.infer<typeof LandingTickerSchema>;
+export type LandingTrustConfig = z.infer<typeof LandingTrustSchema>;
+export type LandingApiShowcaseItemConfig = z.infer<
+  typeof LandingApiShowcaseItemSchema
+>;
+export type LandingApiShowcaseConfig = z.infer<typeof LandingApiShowcaseSchema>;
+export type LandingPricingCtaConfig = z.infer<typeof LandingPricingCtaSchema>;
+
 export type ResolvedLandingContent = {
   hero?: {
     title?: string;
     subtitle?: string;
     description?: string;
+    badge?: string;
+    highlights?: string[];
+    codeExample?: NonNullable<LandingCodeExampleConfig>;
   };
   features?: LandingFeatureConfig[];
   primaryAction?: LandingLinkConfig;
   secondaryAction?: LandingLinkConfig;
+  ticker?: LandingTickerConfig;
+  trust?: LandingTrustConfig;
+  apiShowcase?: LandingApiShowcaseConfig;
+  pricingCta?: LandingPricingCtaConfig;
   showPoweredBy?: boolean;
 };
 

package/src/config/validators/ZudokuConfig.ts

@@ -582,6 +582,7 @@ const ThemeConfigSchema = z.object({
 const SiteSchema = z
   .object({
     title: z.string(),
+    showTitleInHeader: z.boolean().optional(),
     logoUrl: z.string(),
     dir: z.enum(["ltr", "rtl"]).optional(),
     logo: LogoSchema,