@mehdad67/apitogo 0.1.24

package/src/vite/prerender/utils.ts

@@ -0,0 +1,76 @@
+import type { RouteObject } from "react-router";
+import { joinUrl } from "../../lib/util/joinUrl.js";
+
+const resolveRoutePath = (path: string): string | undefined => {
+  const segments = path.split("/");
+  if (segments.some((s) => s.startsWith(":") && !s.endsWith("?"))) {
+    return undefined;
+  }
+  return segments.filter((s) => !s.startsWith(":")).join("/") || undefined;
+};
+
+const isSkipped = (path: string) => path.includes("*") || /^\d+$/.test(path);
+
+export type RouteRewrite = { source: string; destination: string };
+
+type ResolvedRoute = {
+  path: string;
+  hasStrippedParams: boolean;
+  children: ResolvedRoute[];
+};
+
+const resolveRoutes = (
+  routes: RouteObject[],
+  parentPath = "",
+): ResolvedRoute[] =>
+  routes.flatMap((route) => {
+    if (route.path && isSkipped(route.path)) return [];
+
+    const routePath = route.path ? resolveRoutePath(route.path) : undefined;
+    if (route.path && !routePath) return [];
+
+    const fullPath = routePath
+      ? routePath.startsWith("/")
+        ? routePath
+        : joinUrl(parentPath, routePath)
+      : parentPath;
+
+    const hasStrippedParams =
+      route.path?.split("/").some((s) => s.startsWith(":")) ?? false;
+
+    return [
+      {
+        path: fullPath,
+        hasStrippedParams,
+        children: resolveRoutes(route.children ?? [], fullPath),
+      },
+    ];
+  });
+
+const collectPaths = (
+  resolved: ResolvedRoute[],
+  parentPath: string,
+): string[] =>
+  resolved.flatMap((r) => [
+    ...(r.path !== parentPath ? [r.path] : []),
+    ...collectPaths(r.children, r.path),
+  ]);
+
+const collectRewrites = (resolved: ResolvedRoute[]): RouteRewrite[] =>
+  resolved.flatMap((r) => [
+    ...(r.hasStrippedParams && r.path
+      ? [
+          {
+            source: `${r.path}/(.+)`,
+            destination: r.path === "/" ? "/index.html" : `${r.path}.html`,
+          },
+        ]
+      : []),
+    ...collectRewrites(r.children),
+  ]);
+
+export const routesToPaths = (routes: RouteObject[]): string[] =>
+  collectPaths(resolveRoutes(routes), "");
+
+export const routesToRewrites = (routes: RouteObject[]): RouteRewrite[] =>
+  collectRewrites(resolveRoutes(routes));

package/src/vite/prerender/worker.ts

@@ -0,0 +1,118 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import Piscina from "piscina";
+import { matchPath } from "react-router";
+import { ProtectedRoutesSchema } from "../../config/validators/ProtectedRoutesSchema.js";
+import type { ZudokuConfig } from "../../config/validators/ZudokuConfig.js";
+import { runPluginTransformConfig } from "../../lib/core/transform-config.js";
+import { joinUrl } from "../../lib/util/joinUrl.js";
+import type { WorkerResult } from "./prerender.js";
+
+type EntryServer = typeof import("../../app/entry.server.js");
+
+export type StaticWorkerData = {
+  template: string;
+  distDir: string;
+  serverConfigPath: string;
+  entryServerPath: string;
+  writeRedirects: boolean;
+};
+
+export type WorkerData = { urlPath: string };
+
+const { template, distDir, serverConfigPath, entryServerPath, writeRedirects } =
+  Piscina.workerData as StaticWorkerData;
+
+const server: EntryServer = await import(entryServerPath);
+const rawConfig: ZudokuConfig = await import(serverConfigPath).then(
+  (m) => m.default,
+);
+const config = await runPluginTransformConfig(rawConfig);
+
+const routes = server.getRoutesByConfig(config);
+const { basePath } = config;
+
+const renderPage = async ({ urlPath }: WorkerData): Promise<WorkerResult> => {
+  const filename = urlPath === "/" ? "/index.html" : `${urlPath}.html`;
+  const pathname = joinUrl(basePath, urlPath);
+  const url = joinUrl("http://localhost", pathname);
+  const outputPath = path.join(distDir, filename);
+
+  const request = new Request(url);
+
+  const protectedRoutes = ProtectedRoutesSchema.parse(config.protectedRoutes);
+  const isProtectedRoute = protectedRoutes
+    ? Object.keys(protectedRoutes).some((route) =>
+        matchPath({ path: route, end: true }, urlPath),
+      )
+    : false;
+
+  // Get the main response
+  const response = await server.handleRequest({
+    template,
+    request,
+    routes,
+    basePath,
+  });
+
+  // Check for redirects
+  if ([301, 302, 303, 307, 308].includes(response.status)) {
+    const redirectTo = response.headers.get("Location") ?? "";
+
+    if (writeRedirects) {
+      const redirectHtml = `<!doctype html><script>window.location.href=${JSON.stringify(redirectTo)};</script>`;
+      await fs.mkdir(path.dirname(outputPath), { recursive: true });
+      await fs.writeFile(outputPath, redirectHtml);
+    }
+
+    return {
+      outputPath,
+      redirect: { from: pathname, to: redirectTo },
+      statusCode: response.status,
+      html: "",
+    };
+  }
+
+  if (response.status >= 500) {
+    throw new Error(
+      `SSR failed with status ${response.status} for path: ${urlPath}`,
+    );
+  }
+
+  // Get HTML content for file write
+  const fileContent = response.body ? await response.text() : "";
+
+  // For protected routes, do a second render with protection bypassed for search index
+  let html = fileContent;
+  if (isProtectedRoute) {
+    const bypassRequest = new Request(url);
+    const bypassResponse = await server.handleRequest({
+      template,
+      request: bypassRequest,
+      routes,
+      basePath,
+      bypassProtection: true,
+    });
+
+    if (bypassResponse.status >= 500) {
+      throw new Error(
+        `SSR failed (bypass render) with status ${bypassResponse.status} for path: ${urlPath}`,
+      );
+    }
+
+    html = bypassResponse.body ? await bypassResponse.text() : "";
+  }
+
+  // Write the file
+  await fs.mkdir(path.dirname(outputPath), { recursive: true });
+  await fs.writeFile(outputPath, fileContent);
+
+  return {
+    outputPath,
+    statusCode: response.status,
+    redirect: undefined,
+    html,
+  };
+};
+
+export default renderPage;

package/src/vite/reporter.ts

@@ -0,0 +1,34 @@
+// Source: https://github.com/vitejs/vite/blob/e1fa067e65a11e422b6fd94d4ce916a675ebb9a5/packages/vite/src/node/plugins/reporter.ts#L49
+
+export function writeLine(output: string) {
+  clearLine();
+  if (output.length < process.stdout.columns) {
+    process.stdout.write(output);
+  } else {
+    process.stdout.write(output.substring(0, process.stdout.columns - 1));
+  }
+}
+
+export function isTTY() {
+  return process.stdout.isTTY && !process.env.CI;
+}
+
+function clearLine() {
+  if (isTTY()) {
+    process.stdout.clearLine(0);
+    process.stdout.cursorTo(0);
+  }
+}
+
+// biome-ignore lint/complexity/noBannedTypes: todo
+export function throttle(fn: Function) {
+  let timerHandle: NodeJS.Timeout | null = null;
+  // biome-ignore lint/suspicious/noExplicitAny: Allow any type
+  return (...args: any[]) => {
+    if (timerHandle) return;
+    fn(...args);
+    timerHandle = setTimeout(() => {
+      timerHandle = null;
+    }, 100);
+  };
+}

package/src/vite/shadcn-registry.ts

@@ -0,0 +1,48 @@
+import { z } from "zod";
+
+// Taken and simplified from https://github.com/shadcn-ui/ui/blob/main/packages/shadcn/src/registry/schema.ts
+const registryItemCssSchema = z.record(
+  z.string(),
+  z.lazy(() =>
+    z.union([
+      z.string(),
+      z.record(
+        z.string(),
+        z.union([z.string(), z.record(z.string(), z.string())]),
+      ),
+    ]),
+  ),
+);
+
+export type RegistryItemCss = z.infer<typeof registryItemCssSchema>;
+
+const registryItemSchema = z.object({
+  $schema: z.literal("https://ui.shadcn.com/schema/registry-item.json"),
+  name: z.string(),
+  type: z.enum(["registry:theme", "registry:style"]),
+  cssVars: z
+    .object({
+      theme: z.record(z.string(), z.string()).optional(),
+      light: z.record(z.string(), z.string()).optional(),
+      dark: z.record(z.string(), z.string()).optional(),
+    })
+    .optional(),
+  css: registryItemCssSchema.optional(),
+});
+
+type RegistryItem = z.infer<typeof registryItemSchema>;
+
+export const fetchShadcnRegistryItem = async (
+  url: string,
+): Promise<RegistryItem> => {
+  const response = await fetch(url);
+
+  if (!response.ok) {
+    throw new Error(`Failed to fetch shadcn registry item from ${url}`);
+  }
+
+  const data = await response.json();
+  const result = registryItemSchema.parse(data);
+
+  return result;
+};

package/src/vite/sitemap.ts

@@ -0,0 +1,78 @@
+import { createWriteStream, existsSync } from "node:fs";
+import { mkdir } from "node:fs/promises";
+import path from "node:path";
+import colors from "picocolors";
+import { SitemapStream } from "sitemap";
+import type { ZudokuSiteMapConfig } from "../config/validators/ZudokuConfig.js";
+import { joinUrl } from "../lib/util/joinUrl.js";
+export async function generateSitemap({
+  outputUrls,
+  basePath,
+  baseOutputDir,
+  config,
+  redirectUrls,
+}: {
+  basePath: string | undefined;
+  outputUrls: string[];
+  baseOutputDir: string;
+  config: ZudokuSiteMapConfig;
+  redirectUrls: Set<string>;
+}) {
+  if (!config) {
+    return;
+  }
+
+  const sitemap = new SitemapStream({ hostname: config.siteUrl });
+
+  const outputDir = path.resolve(baseOutputDir, config.outDir ?? "");
+
+  // Ensure the output directory exists
+  if (!existsSync(outputDir)) {
+    await mkdir(outputDir, { recursive: true });
+  }
+
+  const sitemapOutputPath = path.join(outputDir, "sitemap.xml");
+
+  const writeStream = createWriteStream(sitemapOutputPath);
+  sitemap.pipe(writeStream);
+
+  let lastmod: string | undefined;
+  if (config.autoLastmod !== false) {
+    lastmod = new Date().toISOString();
+  }
+
+  const exclude =
+    (typeof config.exclude === "function"
+      ? await config.exclude()
+      : config.exclude) ?? [];
+
+  for (const url of outputUrls) {
+    const shouldExclude =
+      exclude.includes(url) ||
+      url.includes("*") ||
+      /(400|404|500)$/.test(url) ||
+      redirectUrls.has(url);
+
+    if (shouldExclude) continue;
+
+    sitemap.write({
+      url: new URL(joinUrl(basePath, url), config.siteUrl).toString(),
+      lastmod,
+      changefreq: config.changefreq ?? "daily",
+      priority: config.priority ?? 0.7,
+    });
+  }
+
+  sitemap.end();
+
+  // Wait for the write stream to finish
+  await new Promise<void>((resolve, reject) => {
+    writeStream.on("finish", resolve);
+    writeStream.on("error", reject);
+  });
+
+  // biome-ignore lint/suspicious/noConsole: Logging allowed here
+  console.debug(
+    colors.blue(`✓ wrote sitemap to ${colors.bold(sitemapOutputPath)}`),
+  );
+}

package/src/vite/ssr-templates/cloudflare.ts

@@ -0,0 +1,19 @@
+// @ts-nocheck
+import { Hono } from "hono";
+import { getRoutesByConfig, handleRequest } from "./entry.server.js";
+const config = await import("__CONFIG_FILE__");
+
+// Cloudflare Workers with Static Assets feature
+// Static files served automatically via wrangler.toml: assets = { directory = "./dist/client" }
+
+const template = "__TEMPLATE__";
+const basePath = "__BASE_PATH__";
+const routes = getRoutesByConfig(config.default ?? config);
+
+const app = new Hono();
+
+app.all("*", (c) =>
+  handleRequest({ template, request: c.req.raw, routes, basePath }),
+);
+
+export default app;

package/src/vite/ssr-templates/node.ts

@@ -0,0 +1,25 @@
+// @ts-nocheck
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { serve } from "@hono/node-server";
+import { serveStatic } from "@hono/node-server/serve-static";
+import { Hono } from "hono";
+import { getRoutesByConfig, handleRequest } from "./entry.server.js";
+const config = await import("__CONFIG_FILE__");
+
+const template = "__TEMPLATE__";
+const basePath = "__BASE_PATH__";
+const routes = getRoutesByConfig(config.default ?? config);
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const staticDir = join(__dirname, "..");
+
+const app = new Hono();
+
+app.use("/server/*", (c) => c.notFound());
+app.use("*", serveStatic({ root: staticDir }));
+app.get("*", (c) =>
+  handleRequest({ template, request: c.req.raw, routes, basePath }),
+);
+
+serve({ fetch: app.fetch, port: Number(process.env.PORT || 3000) });

package/src/vite/ssr-templates/vercel.ts

@@ -0,0 +1,22 @@
+// @ts-nocheck
+import { Hono } from "hono";
+import { getRoutesByConfig, handleRequest } from "./entry.server.js";
+const zudokuConfig = await import("__CONFIG_FILE__");
+
+// Vercel Edge Functions
+// Static files served automatically from dist/client via vercel.json rewrites
+
+const template = "__TEMPLATE__";
+const basePath = "__BASE_PATH__";
+const routes = getRoutesByConfig(zudokuConfig.default ?? zudokuConfig);
+
+const app = new Hono();
+
+app.all("*", (c) =>
+  handleRequest({ template, request: c.req.raw, routes, basePath }),
+);
+
+export const GET = (req: Request) => app.fetch(req);
+export const POST = (req: Request) => app.fetch(req);
+
+export const config = { runtime: "edge" };

package/src/vite/zuplo.ts

@@ -0,0 +1,30 @@
+import bs58 from "bs58";
+
+export type ZuploEnvironmentVariables = {
+  __ZUPLO_DEPLOYMENT_NAME?: string;
+  __ZUPLO_LOGGING_ID?: string;
+  __ZUPLO_REMOTE_LOG_TOKEN?: string;
+  __ZUPLO_AUTH_API_JWT?: string;
+  __ZUPLO_EXTERNAL_SERVICE_TOKEN?: string;
+  ZUPLO_ENVIRONMENT_TYPE?: "PRODUCTION" | "DEVELOPMENT" | "STAGING";
+  ZUPLO_PROJECT_ID?: string;
+  ZUPLO_API_KEY_SERVICE_BUCKET_NAME?: string;
+  ZUPLO_SERVICE_BUCKET_ID?: string;
+  __ZUPLO_CONFIG?: string;
+};
+
+export const getZuploSystemConfigurations = (string?: string) => {
+  if (!string) return undefined;
+
+  try {
+    const zuploSystemConfigurations: ZuploEnvironmentVariables = JSON.parse(
+      Buffer.from(bs58.decode(string)).toString("utf8"),
+    );
+
+    return zuploSystemConfigurations;
+  } catch (error) {
+    // biome-ignore lint/suspicious/noConsole: Logging allowed here
+    console.error(error);
+    return undefined;
+  }
+};

package/src/vite-env.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="vite/client" />
+
+interface ImportMetaEnv {
+  readonly IS_ZUPLO: boolean;
+  readonly ZUPLO_BUILD_ID?: string;
+}

package/src/zuplo/enrich-with-zuplo-mcp.ts

@@ -0,0 +1,168 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import type {
+  ExtensionMcpServer,
+  ExtensionMcpServerTool,
+} from "@zuplo/mcp/openapi/types";
+import {
+  DEFAULT_MCP_SERVER_NAME,
+  DEFAULT_MCP_SERVER_VERSION,
+} from "@zuplo/mcp/server";
+import type { OpenAPIV3_1 } from "openapi-types";
+import type { ProcessorArg } from "../config/validators/BuildSchema.js";
+import { traverse, traverseAsync } from "../lib/util/traverse.js";
+import type { RecordAny } from "../lib/util/types.js";
+import { operations } from "./enrich-with-zuplo.js";
+
+// extracts x-mcp-server metadata from the operation using x-zuplo-mcp-tool
+// as a first class citizen.
+const extractOperationSchema = (
+  operation: OpenAPIV3_1.OperationObject & RecordAny,
+): ExtensionMcpServerTool | null => {
+  if (!operation.operationId) return null;
+
+  // Check if tool is explicitly disabled
+  const mcpToolConfig = operation["x-zuplo-mcp-tool"];
+  if (mcpToolConfig?.enabled === false) {
+    return null;
+  }
+
+  const tool: ExtensionMcpServerTool = {
+    // Use custom name from x-zuplo-mcp-tool or fallback to operationId
+    name: mcpToolConfig?.name || operation.operationId,
+
+    // Use custom description from x-zuplo-mcp-tool or fallback
+    // to operation description
+    description:
+      mcpToolConfig?.description ||
+      operation.summary ||
+      operation.description ||
+      `Operation ${operation.operationId}`,
+  };
+
+  // Grab valid request body JSON schema for the tool
+  const requestBody = operation.requestBody as
+    | OpenAPIV3_1.RequestBodyObject
+    | undefined;
+
+  const schema = requestBody?.content?.["application/json"]?.schema;
+  if (schema && typeof schema === "object") {
+    // TODO: @jpmcb - Zuplo also supports in-path parameters and query parameters
+    // as MCP "inputSchema" arguments. In order to document full argument params,
+    // Zudoku will need to more intelligently parse these elements of an operation.
+    tool.inputSchema = { body: schema };
+  }
+
+  return tool;
+};
+
+// Builds a lookup map of operationId -> operation for efficient access
+const buildOperationLookup = (
+  document: OpenAPIV3_1.Document,
+): Map<string, OpenAPIV3_1.OperationObject> => {
+  const operationMap = new Map<string, OpenAPIV3_1.OperationObject>();
+
+  traverse(document, (node, path) => {
+    // Check if we're at a path item level (paths -> /some/path -> method)
+    // and validate it's in allowed operations
+    if (
+      !path ||
+      path.length < 2 ||
+      path[0] !== "paths" ||
+      !operations.includes(path[path.length - 1] as string)
+    ) {
+      return node;
+    }
+
+    if (node.operationId) {
+      operationMap.set(node.operationId, node);
+    }
+
+    return node;
+  });
+
+  return operationMap;
+};
+
+// Takes an OpenAPI document and returns the x-mcp-server tools list defined
+// by an MCP server's options.files[x].operationIds array.
+const findOperationsInDocument = (
+  document: OpenAPIV3_1.Document,
+  operationIds: string[],
+): ExtensionMcpServerTool[] => {
+  const tools: ExtensionMcpServerTool[] = [];
+  const operationLookup = buildOperationLookup(document);
+
+  operationIds.forEach((operationId) => {
+    const operation = operationLookup.get(operationId);
+    if (operation) {
+      const tool = extractOperationSchema(operation);
+      if (tool) {
+        tools.push(tool);
+      }
+    }
+  });
+
+  return tools;
+};
+
+// Enriches an OpenAPI schema with x-mcp-server data based on the Zuplo MCP server handler
+export const enrichWithZuploMcpServerData = ({
+  rootDir,
+}: {
+  rootDir: string;
+}) => {
+  return async ({ schema }: ProcessorArg) => {
+    if (!schema.paths) return schema;
+    const modifiedSchema = { ...schema };
+    if (!modifiedSchema?.paths) return modifiedSchema;
+
+    await traverseAsync(modifiedSchema, async (node, nodePath) => {
+      // Check if we're at a "post" operation (paths -> /some/path -> "post").
+      // HTTP MCP servers are only allow post operations.
+      if (!nodePath || nodePath.length !== 3 || nodePath[2] !== "post") {
+        return node;
+      }
+
+      const operation = node as RecordAny;
+      if (!operation?.["x-zuplo-route"]) return node;
+
+      const handler = operation["x-zuplo-route"]?.handler;
+      if (handler?.export !== "mcpServerHandler" || !handler.options?.files)
+        return node;
+
+      const tools: ExtensionMcpServerTool[] = [];
+
+      for (const fileConfig of handler.options.files) {
+        if (!fileConfig.path || !fileConfig.operationIds) continue;
+
+        const resolvedPath = path.resolve(rootDir, "../", fileConfig.path);
+        const fileContent = await fs.readFile(resolvedPath, "utf-8");
+        const document = JSON.parse(fileContent);
+
+        if (document) {
+          const fileTools = findOperationsInDocument(
+            document,
+            fileConfig.operationIds,
+          );
+
+          tools.push(...fileTools);
+        }
+      }
+
+      const mcpExtension: ExtensionMcpServer = {
+        name: DEFAULT_MCP_SERVER_NAME,
+        version: DEFAULT_MCP_SERVER_VERSION,
+      };
+
+      if (tools.length > 0) {
+        mcpExtension.tools = tools;
+      }
+
+      node["x-mcp-server"] = mcpExtension;
+      return node;
+    });
+
+    return modifiedSchema;
+  };
+};