@mehdad67/apitogo 0.1.24

package/src/vite/mdx/remark-code-tabs.ts

@@ -0,0 +1,47 @@
+import type { Root } from "mdast";
+import type { MdxJsxAttribute, MdxJsxFlowElement } from "mdast-util-mdx";
+import { visit } from "unist-util-visit";
+
+const attr = (
+  name: string,
+  value: string | null | undefined,
+): MdxJsxAttribute | undefined =>
+  value != null ? { type: "mdxJsxAttribute", name, value } : undefined;
+
+export const remarkCodeTabs = () => (tree: Root) => {
+  visit(tree, "mdxJsxFlowElement", (node: MdxJsxFlowElement) => {
+    if (node.name !== "CodeTabs") return;
+
+    const newChildren: MdxJsxFlowElement["children"] = [];
+    for (const child of node.children) {
+      if (child.type === "code") {
+        const attributes = [
+          attr("language", child.lang),
+          attr("meta", child.meta),
+          attr("code", child.value),
+        ].filter((a) => a !== undefined);
+
+        newChildren.push({
+          type: "mdxJsxFlowElement",
+          name: "CodeTabPanel",
+          attributes,
+          children: [],
+          data: { _mdxExplicitJsx: true },
+        } as MdxJsxFlowElement);
+        continue;
+      }
+
+      // Skip whitespace-only paragraph nodes between code blocks
+      if (
+        child.type === "paragraph" &&
+        child.children.every((c) => c.type === "text" && !c.value.trim())
+      ) {
+        continue;
+      }
+
+      newChildren.push(child);
+    }
+
+    node.children = newChildren;
+  });
+};

package/src/vite/mdx/remark-inject-filepath.ts

@@ -0,0 +1,13 @@
+import path from "node:path";
+import type { Root } from "mdast";
+import type { VFile } from "vfile";
+import { exportMdxjsConst } from "./utils.js";
+
+export const remarkInjectFilepath =
+  (rootDir: string) => (tree: Root, vfile: VFile) => {
+    const relativePath = path
+      .relative(rootDir, vfile.path)
+      .split(path.sep)
+      .join(path.posix.sep);
+    tree.children.unshift(exportMdxjsConst("__filepath", relativePath));
+  };

package/src/vite/mdx/remark-last-modified.ts

@@ -0,0 +1,103 @@
+// biome-ignore-all lint/suspicious/noConsole: Console output allowed here
+import { spawnSync } from "node:child_process";
+import { stat } from "node:fs/promises";
+import type { Root } from "mdast";
+import { visit } from "unist-util-visit";
+import type { VFile } from "vfile";
+import { parse, stringify } from "yaml";
+
+let isGitAvailable: boolean;
+let hasWarnedShallowClone = false;
+
+const checkGitAvailable = (): boolean => {
+  if (isGitAvailable !== undefined) return isGitAvailable;
+
+  const result = spawnSync("git", ["--version"], { stdio: "ignore" });
+  isGitAvailable = result.status === 0;
+
+  return isGitAvailable;
+};
+
+const isShallowRepository = (): boolean => {
+  if (!checkGitAvailable()) return false;
+
+  const result = spawnSync("git", ["rev-parse", "--is-shallow-repository"], {
+    encoding: "utf-8",
+    stdio: ["pipe", "pipe", "ignore"],
+  });
+
+  return result.status === 0 && result.stdout.trim() === "true";
+};
+
+const warnShallowClone = (): void => {
+  if (hasWarnedShallowClone) return;
+  hasWarnedShallowClone = true;
+
+  if (process.env.VERCEL) {
+    console.warn(
+      "The repository is shallow cloned, so the latest modified time may not be accurate. Set the VERCEL_DEEP_CLONE=true environment variable to enable deep cloning.",
+    );
+  } else if (process.env.GITHUB_ACTIONS) {
+    console.warn(
+      "The repository is shallow cloned, so the latest modified time may not be accurate. See https://github.com/actions/checkout#fetch-all-history-for-all-tags-and-branches to fetch all the history.",
+    );
+  } else {
+    console.warn(
+      "The repository is shallow cloned, so the latest modified time may not be accurate.",
+    );
+  }
+};
+
+const getLastModifiedDate = async (filePath: string) => {
+  if (checkGitAvailable()) {
+    const result = spawnSync(
+      "git",
+      ["log", "-1", "--format=%cI", "--", filePath],
+      { encoding: "utf-8", stdio: ["pipe", "pipe", "ignore"] },
+    );
+
+    if (result.status === 0 && result.stdout) {
+      const gitDate = result.stdout.trim();
+      if (gitDate) return new Date(gitDate);
+    }
+  }
+
+  try {
+    const stats = await stat(filePath);
+    return stats.mtime;
+  } catch {
+    // File doesn't exist or can't be accessed
+  }
+
+  return new Date();
+};
+
+export const remarkLastModified = () => {
+  // Check for shallow clone and warn once
+  if (isShallowRepository()) {
+    warnShallowClone();
+  }
+
+  return async (tree: Root, vfile: VFile) => {
+    const date = await getLastModifiedDate(vfile.path);
+    const lastModifiedISO = date.toISOString();
+
+    // Update the YAML frontmatter with the last modified time
+    let hasYaml = false;
+    visit(tree, "yaml", (node) => {
+      hasYaml = true;
+      const data = parse(node.value) ?? {};
+      if (!data.lastModifiedTime) {
+        data.lastModifiedTime = lastModifiedISO;
+        node.value = stringify(data).trim();
+      }
+    });
+
+    if (!hasYaml) {
+      tree.children.unshift({
+        type: "yaml",
+        value: stringify({ lastModifiedTime: lastModifiedISO }).trim(),
+      });
+    }
+  };
+};

package/src/vite/mdx/remark-link-rewrite.ts

@@ -0,0 +1,23 @@
+import path from "node:path";
+import type { Root } from "mdast";
+import { visit } from "unist-util-visit";
+
+export const remarkLinkRewrite =
+  (basePath = "") =>
+  (tree: Root) => {
+    visit(tree, "link", (node) => {
+      if (!node.url) return;
+      if (node.url.startsWith("http") || node.url.startsWith("mailto:")) return;
+
+      node.url = node.url.replace(/\\/g, "/");
+
+      const base = path.posix.join(basePath);
+      if (basePath && node.url.startsWith(base)) {
+        node.url = node.url.slice(base.length);
+      } else if (!node.url.startsWith("/") && !node.url.startsWith("#")) {
+        node.url = path.posix.join("..", node.url);
+      }
+
+      node.url = node.url.replace(/\.mdx?(#.*)?$/, "$1");
+    });
+  };

package/src/vite/mdx/remark-normalize-image-url.ts

@@ -0,0 +1,15 @@
+import type { Root } from "mdast";
+import { visit } from "unist-util-visit";
+import { joinUrl } from "../../lib/util/joinUrl.js";
+
+export const remarkNormalizeImageUrl = (basePath: string) => (tree: Root) => {
+  visit(tree, "image", (node) => {
+    if (
+      node.url.startsWith("/") &&
+      basePath &&
+      !node.url.startsWith(basePath)
+    ) {
+      node.url = joinUrl(basePath, node.url);
+    }
+  });
+};

package/src/vite/mdx/remark-static-generation.ts

@@ -0,0 +1,149 @@
+import vm, { type Context as VmContext } from "node:vm";
+import type { ImportDeclaration, Program } from "estree";
+import { valueToEstree } from "estree-util-value-to-estree";
+import type { Root } from "mdast";
+import type { MdxjsEsm } from "mdast-util-mdx";
+import { SKIP, visit } from "unist-util-visit";
+import type { VFile } from "vfile";
+
+const FUNCTION_NAME = "generateStaticData";
+const VARIABLE_NAME = "STATIC_DATA";
+
+const isStaticExport = (program: Program) => {
+  for (const node of program.body) {
+    if (node.type === "ExportNamedDeclaration" && node.declaration) {
+      const decl = node.declaration;
+      if (decl.type === "VariableDeclaration") {
+        // Check variable declarations like: export const _static = () => { ... }
+        for (const declarator of decl.declarations) {
+          if (
+            declarator.id.type === "Identifier" &&
+            declarator.id.name === FUNCTION_NAME &&
+            declarator.init?.type === "ArrowFunctionExpression"
+          ) {
+            return true;
+          }
+        }
+      } else if (
+        decl.type === "FunctionDeclaration" &&
+        decl.id.name === FUNCTION_NAME
+      ) {
+        // Check function declarations like: export function _static() { ... }
+        return true;
+      }
+    }
+  }
+  return false;
+};
+
+const injectResult = (variableName: string, tree: Root, result: unknown) => {
+  const estreeValue = valueToEstree(result, {
+    preserveReferences: true,
+    instanceAsObject: true,
+  });
+
+  tree.children.unshift({
+    type: "mdxjsEsm",
+    value: "",
+    data: {
+      estree: {
+        type: "Program",
+        body: [
+          {
+            type: "VariableDeclaration",
+            declarations: [
+              {
+                type: "VariableDeclarator",
+                id: { type: "Identifier", name: variableName },
+                init: estreeValue,
+              },
+            ],
+            kind: "const",
+          },
+        ],
+        sourceType: "module",
+      },
+    },
+  });
+};
+
+const executeFunction = async (
+  file: VFile,
+  code: string,
+  importNodes: ImportDeclaration[],
+) => {
+  const context: VmContext = {
+    result: "",
+    process,
+    console,
+  };
+
+  code = code.replace(/^\s*export/, "");
+
+  for (const { source, specifiers } of importNodes) {
+    const modulePath = source.value;
+    if (typeof modulePath !== "string") continue;
+
+    const module = await import(modulePath);
+
+    for (const specifier of specifiers) {
+      const localName = specifier.local.name;
+      switch (specifier.type) {
+        case "ImportSpecifier": {
+          if (specifier.imported.type !== "Identifier") continue;
+          const importedName = specifier.imported.name;
+          context[localName] = module[importedName];
+          break;
+        }
+        case "ImportDefaultSpecifier":
+          context[localName] = module.default ?? module;
+          break;
+        case "ImportNamespaceSpecifier":
+          context[localName] = module;
+          break;
+      }
+    }
+  }
+
+  const script = new vm.Script(`
+   (async () => {
+       result = await (async () => { ${code}; return ${FUNCTION_NAME}(); })();
+   })();
+ `);
+
+  const prevCwd = process.cwd();
+  // Run VM relative to the file's directory
+  process.chdir(file.dirname ?? file.cwd);
+  await script.runInNewContext(context);
+  process.chdir(prevCwd);
+
+  return context.result;
+};
+
+export const remarkStaticGeneration = () => async (tree: Root, file: VFile) => {
+  const imports: ImportDeclaration[] = [];
+  const nodesToProcess: MdxjsEsm[] = [];
+
+  visit(tree, "mdxjsEsm", (node) => {
+    const innerTree = node.data?.estree;
+    if (!innerTree) return;
+
+    innerTree.body.forEach((node) => {
+      if (node.type !== "ImportDeclaration") return;
+
+      imports.push(node);
+    });
+
+    if (isStaticExport(innerTree)) {
+      nodesToProcess.push(node);
+      return SKIP;
+    }
+  });
+
+  for (const node of nodesToProcess) {
+    const executed = await executeFunction(file, node.value, imports);
+    if (!executed) continue;
+
+    injectResult(VARIABLE_NAME, tree, executed);
+  }
+};

package/src/vite/mdx/utils.ts

@@ -0,0 +1,32 @@
+import { valueToEstree } from "estree-util-value-to-estree";
+import type { MdxjsEsm } from "mdast-util-mdx";
+
+export const exportMdxjsConst = (name: string, value: unknown): MdxjsEsm => ({
+  type: "mdxjsEsm",
+  value: "",
+  data: {
+    estree: {
+      type: "Program",
+      sourceType: "module",
+      body: [
+        {
+          type: "ExportNamedDeclaration",
+          attributes: [],
+          declaration: {
+            type: "VariableDeclaration",
+            kind: "const",
+            declarations: [
+              {
+                type: "VariableDeclarator",
+                id: { type: "Identifier", name },
+                init: valueToEstree(value),
+              },
+            ],
+          },
+          specifiers: [],
+          source: null,
+        },
+      ],
+    },
+  },
+});

package/src/vite/output.ts

@@ -0,0 +1,261 @@
+import assert from "node:assert";
+import { cp, mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { getZudokuPackageJson } from "../cli/common/package-json.js";
+import type { LoadedConfig } from "../config/config.js";
+import { joinUrl } from "../lib/util/joinUrl.js";
+import type { RouteRewrite } from "./prerender/utils.js";
+
+const pkgJson = getZudokuPackageJson();
+
+// Generates a Vercel build output file
+// https://vercel.com/docs/build-output-api/v3
+
+type Config = {
+  version: 3;
+  routes?: Route[];
+  images?: ImagesConfig;
+  wildcard?: WildcardConfig;
+  overrides?: OverrideConfig;
+  cache?: string[];
+  crons?: CronsConfig;
+  framework?: Framework;
+};
+
+type Route = Source | Handler;
+
+type Source = {
+  src: string;
+  dest?: string;
+  headers?: Record<string, string>;
+  methods?: string[];
+  continue?: boolean;
+  caseSensitive?: boolean;
+  check?: boolean;
+  status?: number;
+  has?: Array<HostHasField | HeaderHasField | CookieHasField | QueryHasField>;
+  missing?: Array<
+    HostHasField | HeaderHasField | CookieHasField | QueryHasField
+  >;
+  locale?: Locale;
+  middlewareRawSrc?: string[];
+  middlewarePath?: string;
+};
+
+type Locale = {
+  redirect?: Record<string, string>;
+  cookie?: string;
+};
+
+type HostHasField = {
+  type: "host";
+  value: string;
+};
+
+type HeaderHasField = {
+  type: "header";
+  key: string;
+  value?: string;
+};
+
+type CookieHasField = {
+  type: "cookie";
+  key: string;
+  value?: string;
+};
+
+type QueryHasField = {
+  type: "query";
+  key: string;
+  value?: string;
+};
+
+type HandleValue =
+  | "rewrite"
+  | "filesystem" // check matches after the filesystem misses
+  | "resource"
+  | "miss" // check matches after every filesystem miss
+  | "hit"
+  | "error"; //  check matches after error (500, 404, etc.)
+
+type Handler = {
+  handle: HandleValue;
+  src?: string;
+  dest?: string;
+  status?: number;
+};
+type ImageFormat = "image/avif" | "image/webp";
+
+type RemotePattern = {
+  protocol?: "http" | "https";
+  hostname: string;
+  port?: string;
+  pathname?: string;
+  search?: string;
+};
+
+type LocalPattern = {
+  pathname?: string;
+  search?: string;
+};
+
+type ImagesConfig = {
+  sizes: number[];
+  domains: string[];
+  remotePatterns?: RemotePattern[];
+  localPatterns?: LocalPattern[];
+  minimumCacheTTL?: number; // seconds
+  formats?: ImageFormat[];
+  dangerouslyAllowSVG?: boolean;
+  contentSecurityPolicy?: string;
+  contentDispositionType?: string;
+};
+
+type WildCard = {
+  domain: string;
+  value: string;
+};
+
+type WildcardConfig = Array<WildCard>;
+
+type Override = {
+  path?: string;
+  contentType?: string;
+};
+
+type OverrideConfig = Record<string, Override>;
+
+type Framework = {
+  version: string;
+};
+
+type Cron = {
+  path: string;
+  schedule: string;
+};
+
+type CronsConfig = Cron[];
+
+export function generateOutput({
+  config,
+  redirects,
+  rewrites = [],
+}: {
+  config: LoadedConfig;
+  redirects: Array<{ from: string; to: string }>;
+  rewrites?: RouteRewrite[];
+}): Config {
+  const routes: Route[] = [];
+
+  for (const redirect of redirects) {
+    routes.push({
+      src: redirect.from,
+      dest: redirect.to,
+      status: 301,
+      headers: { Location: redirect.to },
+    });
+  }
+
+  if (process.env.VERCEL_SKEW_PROTECTION_ENABLED) {
+    assert(process.env.VERCEL_DEPLOYMENT_ID);
+
+    routes.push({
+      src: "/.*",
+      has: [
+        {
+          type: "header",
+          key: "Sec-Fetch-Dest",
+          value: "document",
+        },
+      ],
+      headers: {
+        "Set-Cookie": `__vdpl=${process.env.VERCEL_DEPLOYMENT_ID}; Path=${joinUrl(config.basePath)}; SameSite=Strict; Secure; HttpOnly`,
+      },
+      continue: true,
+    });
+  }
+
+  if (rewrites.length > 0) {
+    routes.push({ handle: "filesystem" });
+    for (const rewrite of rewrites) {
+      routes.push({
+        src: joinUrl(config.basePath, rewrite.source),
+        dest: joinUrl(config.basePath, rewrite.destination),
+      });
+    }
+  }
+
+  const output: Config = {
+    version: 3,
+    framework: {
+      version: pkgJson.version,
+    },
+    routes,
+  };
+
+  return output;
+}
+
+export async function writeOutput(
+  dir: string,
+  {
+    config,
+    redirects,
+    rewrites,
+  }: {
+    config: LoadedConfig;
+    redirects: Array<{ from: string; to: string }>;
+    rewrites?: RouteRewrite[];
+  },
+) {
+  const output = generateOutput({ config, redirects, rewrites });
+  // For now we are putting this in the dist folder, eventually we can
+  // expand this to support the full vercel build output API
+
+  const outputDir = process.env.VERCEL
+    ? path.join(dir, ".vercel/output")
+    : path.join(dir, "dist/.output");
+
+  await mkdir(outputDir, { recursive: true });
+  const outputFile = path.join(outputDir, "config.json");
+  await writeFile(outputFile, JSON.stringify(output, null, 2), "utf-8");
+
+  if (process.env.VERCEL) {
+    // biome-ignore lint/suspicious/noConsole: Logging allowed here
+    console.log("Wrote Vercel output to", outputDir);
+  }
+}
+
+export async function writeVercelSSROutput(dir: string, serverOutDir: string) {
+  // https://vercel.com/docs/build-output-api
+  const outputDir = path.join(dir, ".vercel/output");
+
+  const distDir = path.join(dir, "dist");
+  await cp(distDir, path.join(outputDir, "static"), {
+    recursive: true,
+    filter: (src) =>
+      !path.relative(distDir, src).split(path.sep).includes("server"),
+  });
+
+  const funcDir = path.join(outputDir, "functions/render.func");
+  await mkdir(funcDir, { recursive: true });
+  await cp(serverOutDir, funcDir, { recursive: true });
+
+  // Write .vc-config.json for the edge function (see https://vercel.com/docs/build-output-api/primitives#edge-functions)
+  await writeFile(
+    path.join(funcDir, ".vc-config.json"),
+    JSON.stringify({ runtime: "edge", entrypoint: "entry.js" }),
+  );
+
+  await writeFile(
+    path.join(outputDir, "config.json"),
+    JSON.stringify({
+      version: 3,
+      framework: { version: pkgJson.version },
+      routes: [{ handle: "filesystem" }, { src: "/(.*)", dest: "/render" }],
+    }),
+  );
+
+  // biome-ignore lint/suspicious/noConsole: Logging allowed here
+  console.log("Wrote Vercel SSR output to", outputDir);
+}

package/src/vite/package-root.ts

@@ -0,0 +1,12 @@
+import path from "node:path";
+import { fileExists } from "../config/file-exists.js";
+
+export const findPackageRoot = async (
+  startDir: string,
+): Promise<string | undefined> => {
+  let dir = startDir;
+  while (dir !== path.dirname(dir)) {
+    if (await fileExists(path.join(dir, "package.json"))) return dir;
+    dir = path.dirname(dir);
+  }
+};