@lukoweb/apitogo 0.1.50 → 0.1.53

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

@@ -0,0 +1,485 @@
+export const APITOGO_CONFIG_FILENAME = "apitogo.config.json";
+
+const ENV_PREFIX = "APITOGO_CONFIG_";
+
+/** Derived at read time for platform/MCP — not stored in user JSON. */
+const DERIVED_MANIFEST_KEYS = [
+  "siteName",
+  "branding",
+  "pricing",
+  "authentication",
+  "plans",
+  "backend",
+  "gateway",
+  "projectId",
+] as const;
+
+const SITE_CONFIG_KEYS = [
+  "site",
+  "metadata",
+  "modules",
+  "navigation",
+  "apis",
+  "redirects",
+  "theme",
+  "search",
+  "llms",
+  "protectedRoutes",
+  "slots",
+  "mdx",
+  "catalogs",
+  "versions",
+  "options",
+] as const;
+
+export type ApitogoJsonConfig = Record<string, unknown>;
+
+export type AuthenticationSecrets = {
+  oidc?: {
+    authority?: string;
+    clientId?: string;
+    clientSecret?: string;
+  };
+  stripe?: {
+    secretKey?: string;
+    webhookSecret?: string;
+  };
+};
+
+function parseEnvValue(raw: string | undefined): unknown {
+  if (raw === undefined) {
+    return raw;
+  }
+
+  const trimmed = raw.trim();
+  if (trimmed === "true") {
+    return true;
+  }
+  if (trimmed === "false") {
+    return false;
+  }
+  if (trimmed === "null") {
+    return null;
+  }
+
+  if (/^-?\d+(\.\d+)?$/.test(trimmed)) {
+    return Number(trimmed);
+  }
+
+  if (
+    (trimmed.startsWith("{") && trimmed.endsWith("}")) ||
+    (trimmed.startsWith("[") && trimmed.endsWith("]"))
+  ) {
+    try {
+      return JSON.parse(trimmed) as unknown;
+    } catch {
+      return trimmed;
+    }
+  }
+
+  return trimmed;
+}
+
+function setNestedValue(
+  target: Record<string, unknown>,
+  pathParts: string[],
+  value: unknown,
+): void {
+  if (pathParts.length === 0) {
+    return;
+  }
+
+  let current: Record<string, unknown> = target;
+  for (let index = 0; index < pathParts.length - 1; index += 1) {
+    const key = pathParts[index];
+    if (!key) {
+      return;
+    }
+    const next = current[key];
+    if (
+      next === undefined ||
+      next === null ||
+      typeof next !== "object" ||
+      Array.isArray(next)
+    ) {
+      current[key] = {};
+    }
+    current = current[key] as Record<string, unknown>;
+  }
+
+  const leafKey = pathParts[pathParts.length - 1];
+  if (!leafKey) {
+    return;
+  }
+
+  current[leafKey] = value;
+}
+
+function stripRuntimeConfigFields(
+  config: ApitogoJsonConfig,
+): ApitogoJsonConfig {
+  const { plugins: _plugins, ...jsonOnly } = config as ApitogoJsonConfig & {
+    plugins?: unknown;
+  };
+  return jsonOnly;
+}
+
+export function applyEnvOverrides(
+  config: ApitogoJsonConfig,
+  env: NodeJS.ProcessEnv = process.env,
+): ApitogoJsonConfig {
+  const result = structuredClone(stripRuntimeConfigFields(config));
+
+  for (const [key, value] of Object.entries(env)) {
+    if (!key.startsWith(ENV_PREFIX) || value === undefined) {
+      continue;
+    }
+
+    const pathParts = key.slice(ENV_PREFIX.length).split("__").filter(Boolean);
+
+    if (pathParts.length === 0) {
+      continue;
+    }
+
+    setNestedValue(result, pathParts, parseEnvValue(value));
+  }
+
+  return result;
+}
+
+function asRecord(value: unknown): Record<string, unknown> | undefined {
+  return value !== undefined &&
+    value !== null &&
+    typeof value === "object" &&
+    !Array.isArray(value)
+    ? (value as Record<string, unknown>)
+    : undefined;
+}
+
+function readSiteTitle(config: ApitogoJsonConfig): string | undefined {
+  const site = asRecord(config.site);
+  const branding = asRecord(config.branding);
+  const siteTitle = site?.title;
+  const brandingTitle = branding?.title;
+  const legacySiteName = config.siteName;
+
+  if (typeof siteTitle === "string" && siteTitle.trim()) {
+    return siteTitle.trim();
+  }
+  if (typeof brandingTitle === "string" && brandingTitle.trim()) {
+    return brandingTitle.trim();
+  }
+  if (typeof legacySiteName === "string" && legacySiteName.trim()) {
+    return legacySiteName.trim();
+  }
+
+  return undefined;
+}
+
+function readLogoUrl(config: ApitogoJsonConfig): string | undefined {
+  const site = asRecord(config.site);
+  const logo = asRecord(site?.logo);
+  const src = asRecord(logo?.src);
+  const branding = asRecord(config.branding);
+
+  const fromSite =
+    (typeof src?.light === "string" && src.light) ||
+    (typeof src?.dark === "string" && src.dark) ||
+    (typeof logo?.logoUrl === "string" && logo.logoUrl) ||
+    (typeof site?.logoUrl === "string" && site.logoUrl);
+
+  if (fromSite) {
+    return fromSite;
+  }
+
+  return typeof branding?.logoUrl === "string" ? branding.logoUrl : undefined;
+}
+
+function firstApiInput(config: ApitogoJsonConfig): string | undefined {
+  const apis = config.apis;
+  const list = Array.isArray(apis) ? apis : apis ? [apis] : [];
+  for (const entry of list) {
+    const api = asRecord(entry);
+    if (typeof api?.input === "string" && api.input.trim()) {
+      return api.input.trim();
+    }
+  }
+  return undefined;
+}
+
+function mergeAuthenticationGateway(
+  config: ApitogoJsonConfig,
+): Record<string, unknown> | undefined {
+  const authentication = asRecord(config.authentication);
+  if (!authentication) {
+    return undefined;
+  }
+
+  const authGateway = asRecord(authentication.gateway);
+  const rootGateway = asRecord(config.gateway);
+
+  if (!authGateway && !rootGateway) {
+    return authentication;
+  }
+
+  return {
+    ...authentication,
+    gateway: {
+      ...rootGateway,
+      ...authGateway,
+    },
+  };
+}
+
+function ensureModules(config: ApitogoJsonConfig): Record<string, unknown> {
+  const modules = asRecord(config.modules) ?? {};
+  config.modules = modules;
+  return modules;
+}
+
+type PlanCatalogItem = Record<string, unknown> & { sku?: string };
+
+function mergePlansBySku(
+  existing: PlanCatalogItem[],
+  patch: PlanCatalogItem[],
+): PlanCatalogItem[] {
+  const bySku = new Map<string, PlanCatalogItem>();
+  for (const plan of existing) {
+    if (typeof plan.sku === "string") {
+      bySku.set(plan.sku, plan);
+    }
+  }
+  for (const plan of patch) {
+    if (typeof plan.sku !== "string") {
+      continue;
+    }
+    const prior = bySku.get(plan.sku);
+    bySku.set(plan.sku, prior ? { ...prior, ...plan } : plan);
+  }
+  return Array.from(bySku.values());
+}
+
+/** Gateway plan catalog stored under `modules.userPanel.plans.items`. */
+export function readPlanCatalogItems(
+  config: ApitogoJsonConfig,
+): PlanCatalogItem[] {
+  const normalized = normalizeApitogoConfig(config);
+  const items = asRecord(
+    asRecord(asRecord(normalized.modules)?.userPanel)?.plans,
+  )?.items;
+  return Array.isArray(items) ? (items as PlanCatalogItem[]) : [];
+}
+
+function migratePlanCatalog(normalized: ApitogoJsonConfig): void {
+  const modules = ensureModules(normalized);
+  const userPanel = asRecord(modules.userPanel) ?? {};
+  const plansModule = asRecord(userPanel.plans) ?? {};
+  const rootList = Array.isArray(normalized.plans)
+    ? (normalized.plans as PlanCatalogItem[])
+    : [];
+  const existingItems = Array.isArray(plansModule.items)
+    ? (plansModule.items as PlanCatalogItem[])
+    : [];
+
+  if (rootList.length) {
+    plansModule.items = mergePlansBySku(existingItems, rootList);
+    if (plansModule.enabled === undefined) {
+      plansModule.enabled = true;
+    }
+    userPanel.plans = plansModule;
+    modules.userPanel = userPanel;
+  }
+
+  delete normalized.plans;
+}
+
+/** Collapse legacy duplicate fields into canonical shape (mutates copy). */
+export function normalizeApitogoConfig(
+  config: ApitogoJsonConfig,
+): ApitogoJsonConfig {
+  const normalized = structuredClone(stripRuntimeConfigFields(config));
+  const title = readSiteTitle(normalized);
+  const logoUrl = readLogoUrl(normalized);
+
+  const site = asRecord(normalized.site) ?? {};
+  if (title) {
+    site.title = title;
+  }
+  if (logoUrl && !asRecord(site.logo)?.src) {
+    site.logo = {
+      ...(asRecord(site.logo) ?? {}),
+      src: { light: logoUrl, dark: logoUrl },
+    };
+  }
+  normalized.site = site;
+
+  const authentication = mergeAuthenticationGateway(normalized);
+  if (authentication) {
+    normalized.authentication = authentication;
+  }
+  delete normalized.gateway;
+
+  const modules = ensureModules(normalized);
+  const legacyDocs = asRecord(normalized.docs);
+  const moduleDocs = asRecord(modules.docs) ?? {};
+  if (legacyDocs) {
+    modules.docs = { ...legacyDocs, ...moduleDocs };
+  }
+  delete normalized.docs;
+
+  const legacyApiKeys = asRecord(normalized.apiKeys);
+  const userPanel = asRecord(modules.userPanel) ?? {};
+  const apiKeys = asRecord(userPanel.apiKeys) ?? {};
+  if (legacyApiKeys?.enabled === true && apiKeys.enabled === undefined) {
+    userPanel.apiKeys = { ...apiKeys, enabled: true };
+    modules.userPanel = userPanel;
+  }
+  delete normalized.apiKeys;
+
+  const apiInput = firstApiInput(normalized);
+  if (apiInput) {
+    const backend = asRecord(normalized.backend) ?? {};
+    if (!backend.openApiPath) {
+      backend.openApiPath = apiInput;
+    }
+    normalized.backend = backend;
+  }
+
+  delete normalized.siteName;
+  delete normalized.branding;
+  delete normalized.projectName;
+
+  migratePlanCatalog(normalized);
+  syncBillingEnabled(normalized);
+
+  return normalized;
+}
+
+/** Billing is controlled by `modules.userPanel.plans.enabled` (legacy `pricing.enabled` is migrated). */
+export function isBillingEnabled(config: ApitogoJsonConfig): boolean {
+  const normalized = normalizeApitogoConfig(config);
+  const plans = asRecord(
+    asRecord(asRecord(normalized.modules)?.userPanel)?.plans,
+  );
+  return plans?.enabled === true;
+}
+
+function syncBillingEnabled(normalized: ApitogoJsonConfig): void {
+  const legacyPricing = asRecord(normalized.pricing);
+  const modules = ensureModules(normalized);
+  const userPanel = asRecord(modules.userPanel) ?? {};
+  const plans = asRecord(userPanel.plans) ?? {};
+
+  const enabled = plans.enabled === true || legacyPricing?.enabled === true;
+
+  if (enabled) {
+    userPanel.plans = { ...plans, enabled: true };
+    modules.userPanel = userPanel;
+  }
+
+  delete normalized.pricing;
+}
+
+export function deriveManifestFields(
+  config: ApitogoJsonConfig,
+): ApitogoJsonConfig {
+  const normalized = normalizeApitogoConfig(config);
+  const manifest: ApitogoJsonConfig = {};
+
+  const title = readSiteTitle(normalized);
+  if (title) {
+    manifest.siteName = title;
+    const logoUrl = readLogoUrl(normalized);
+    manifest.branding = logoUrl ? { title, logoUrl } : { title };
+  }
+
+  for (const key of DERIVED_MANIFEST_KEYS) {
+    if (key === "siteName" || key === "branding") {
+      continue;
+    }
+    if (key === "authentication") {
+      const authentication = asRecord(normalized.authentication);
+      if (authentication) {
+        const {
+          gateway: _gateway,
+          oidc: _oidc,
+          stripe: _stripe,
+          ...authPublic
+        } = authentication;
+        manifest.authentication = authPublic;
+      }
+      continue;
+    }
+    if (key === "gateway") {
+      continue;
+    }
+    if (key === "pricing") {
+      if (isBillingEnabled(config)) {
+        manifest.pricing = { enabled: true };
+      }
+      continue;
+    }
+    if (key === "plans") {
+      const items = readPlanCatalogItems(normalized);
+      if (items.length) {
+        manifest.plans = items;
+      }
+      continue;
+    }
+    if (normalized[key] !== undefined) {
+      manifest[key] = normalized[key];
+    }
+  }
+
+  const authentication = asRecord(normalized.authentication);
+  if (authentication?.gateway) {
+    manifest.gateway = authentication.gateway;
+  }
+
+  return manifest;
+}
+
+export function extractManifest(
+  config: ApitogoJsonConfig | null | undefined,
+): ApitogoJsonConfig | null {
+  if (!config || typeof config !== "object") {
+    return null;
+  }
+
+  const manifest = deriveManifestFields(config);
+  return Object.keys(manifest).length > 0 ? manifest : null;
+}
+
+export function extractSiteConfig(
+  config: ApitogoJsonConfig | null | undefined,
+): ApitogoJsonConfig {
+  if (!config || typeof config !== "object") {
+    return {};
+  }
+
+  const normalized = normalizeApitogoConfig(config);
+  const siteConfig: ApitogoJsonConfig = {};
+
+  for (const key of SITE_CONFIG_KEYS) {
+    if (normalized[key] !== undefined) {
+      siteConfig[key] = normalized[key];
+    }
+  }
+
+  if (normalized.authentication !== undefined) {
+    siteConfig.authentication = normalized.authentication;
+  }
+
+  const modulesDocs = asRecord(asRecord(normalized.modules)?.docs);
+  if (modulesDocs) {
+    const { enabled: _enabled, ...docsConfig } = modulesDocs;
+    siteConfig.docs = docsConfig;
+  }
+
+  return siteConfig;
+}
+
+/** @deprecated Use {@link readSiteTitle} via normalized config — kept for MCP bootstrap naming. */
+export function resolveProjectDisplayName(config: ApitogoJsonConfig): string {
+  return readSiteTitle(config) ?? "Developer Portal";
+}

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

@@ -0,0 +1,68 @@
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import {
+  APITOGO_CONFIG_FILENAME,
+  applyEnvOverrides,
+  type ApitogoJsonConfig,
+  type AuthenticationSecrets,
+  normalizeApitogoConfig,
+} from "./apitogo-config-core.js";
+
+function asRecord(value: unknown): Record<string, unknown> | undefined {
+  return value !== undefined &&
+    value !== null &&
+    typeof value === "object" &&
+    !Array.isArray(value)
+    ? (value as Record<string, unknown>)
+    : undefined;
+}
+
+export function loadApitogoConfig(rootDir = process.cwd()): ApitogoJsonConfig {
+  const configPath = path.join(path.resolve(rootDir), APITOGO_CONFIG_FILENAME);
+
+  if (!existsSync(configPath)) {
+    throw new Error(
+      `Missing ${APITOGO_CONFIG_FILENAME} in ${path.resolve(rootDir)}`,
+    );
+  }
+
+  const raw = readFileSync(configPath, "utf8");
+  const parsed = JSON.parse(raw) as ApitogoJsonConfig;
+  return normalizeApitogoConfig(applyEnvOverrides(parsed, process.env));
+}
+
+export function readAuthenticationSecrets(
+  env: NodeJS.ProcessEnv = process.env,
+): AuthenticationSecrets {
+  const overrides = applyEnvOverrides({}, env);
+  const authentication = asRecord(overrides.authentication);
+  const oidc = asRecord(authentication?.oidc);
+  const stripe = asRecord(authentication?.stripe);
+
+  const secrets: AuthenticationSecrets = {};
+  if (oidc) {
+    secrets.oidc = {
+      authority:
+        typeof oidc.authority === "string" ? oidc.authority : undefined,
+      clientId: typeof oidc.clientId === "string" ? oidc.clientId : undefined,
+      clientSecret:
+        typeof oidc.clientSecret === "string" ? oidc.clientSecret : undefined,
+    };
+  }
+  if (stripe) {
+    secrets.stripe = {
+      secretKey:
+        typeof stripe.secretKey === "string" ? stripe.secretKey : undefined,
+      webhookSecret:
+        typeof stripe.webhookSecret === "string"
+          ? stripe.webhookSecret
+          : undefined,
+    };
+  }
+
+  return secrets;
+}
+
+export function apitogoConfigPath(rootDir: string): string {
+  return path.join(path.resolve(rootDir), APITOGO_CONFIG_FILENAME);
+}

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

@@ -0,0 +1,6 @@
+export * from "./apitogo-config-core.js";
+export {
+  apitogoConfigPath,
+  loadApitogoConfig,
+  readAuthenticationSecrets,
+} from "./apitogo-config-loader.node.js";

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

@@ -0,0 +1,52 @@
+import type { ApitogoPlugin } from "../lib/core/plugins.js";
+import {
+  extractSiteConfig,
+  normalizeApitogoConfig,
+  type ApitogoJsonConfig,
+} from "./apitogo-config-core.js";
+import type { ApitogoConfig } from "./config.js";
+
+type BuildApitogoConfigOptions = Partial<ApitogoConfig> &
+  ApitogoJsonConfig & {
+    plugins?: ApitogoPlugin[];
+  };
+
+export function buildApitogoConfig({
+  plugins,
+  plans: _legacyPlans,
+  ...jsonOverrides
+}: BuildApitogoConfigOptions = {}): ApitogoConfig {
+  const jsonConfig = normalizeApitogoConfig({
+    ...jsonOverrides,
+    ...(_legacyPlans !== undefined ? { plans: _legacyPlans } : {}),
+  } as ApitogoJsonConfig);
+  const siteConfig = extractSiteConfig(jsonConfig);
+  const { plans: _rootPlans, ...restOverrides } =
+    jsonOverrides as ApitogoJsonConfig;
+
+  return {
+    ...siteConfig,
+    ...restOverrides,
+    plugins,
+    authentication: {
+      ...(siteConfig.authentication as ApitogoConfig["authentication"]),
+      ...jsonOverrides.authentication,
+    },
+    site: {
+      ...(siteConfig.site as ApitogoConfig["site"]),
+      ...jsonOverrides.site,
+    },
+    metadata: {
+      ...(siteConfig.metadata as ApitogoConfig["metadata"]),
+      ...jsonOverrides.metadata,
+    },
+    docs: {
+      ...(siteConfig.docs as ApitogoConfig["docs"]),
+      ...jsonOverrides.docs,
+    },
+    modules: {
+      ...(jsonConfig.modules as ApitogoConfig["modules"]),
+      ...jsonOverrides.modules,
+    },
+  } as ApitogoConfig;
+}