@mehdad67/apitogo 0.1.24

package/src/app/standalone.tsx

@@ -0,0 +1,60 @@
+import { createRoot } from "react-dom/client";
+import { createBrowserRouter } from "react-router";
+import type { ZudokuConfig } from "../config/validators/ZudokuConfig.js";
+import { Bootstrap } from "../lib/components/Bootstrap.js";
+import { openApiPlugin } from "../lib/plugins/openapi/index.js";
+import "../lib/util/logInit.js";
+import "./main.css";
+import { getRoutesByConfig } from "./main.js";
+
+const root = document.querySelector("div[data-api-url]");
+if (!root) {
+  throw new Error("No div found with attribute data-api-url");
+}
+
+const apiUrl = root.getAttribute("data-api-url");
+
+if (!apiUrl) {
+  throw new Error("No api url found");
+}
+
+const title = document.getElementsByTagName("title")[0]?.innerText;
+const logoUrl = root.getAttribute("data-logo-url");
+
+// IMPORTANT: This component must not contain tailwind classes
+// This directory is not processed by the tailwind plugin
+
+const config = {
+  site: {
+    logo: logoUrl
+      ? {
+          src: {
+            light: logoUrl,
+            dark: logoUrl,
+          },
+        }
+      : undefined,
+    title,
+  },
+  navigation: [
+    {
+      type: "link",
+      label: "API Reference",
+      to: "/",
+    },
+  ],
+  plugins: [
+    // Using the plugin directly because there's no config file to load in the virtual plugins
+    openApiPlugin({
+      type: "url",
+      input: apiUrl,
+      path: "/",
+    }),
+  ],
+} satisfies ZudokuConfig;
+
+const routes = getRoutesByConfig(config);
+const router = createBrowserRouter(routes, {
+  basename: window.location.pathname,
+});
+createRoot(root).render(<Bootstrap router={router} />);

package/src/app/utils/createRedirectRoutes.ts

@@ -0,0 +1,11 @@
+import { redirect, type RouteObject } from "react-router";
+import type { ZudokuRedirect } from "../../config/validators/ZudokuConfig.js";
+import { joinUrl } from "../../lib/util/joinUrl.js";
+
+export const createRedirectRoutes = (
+  redirects?: ZudokuRedirect[],
+): RouteObject[] =>
+  (redirects ?? []).map((r) => ({
+    path: joinUrl(r.from),
+    loader: () => redirect(r.to, 301),
+  }));

package/src/config/config.ts

@@ -0,0 +1,70 @@
+import type { ConfigWithMeta } from "./loader.js";
+import type { BuildConfig } from "./validators/BuildSchema.js";
+import type {
+  AuthenticationConfig,
+  ZudokuConfig,
+} from "./validators/ZudokuConfig.js";
+
+/** Build-time config for APIToGo (`apitogo.build.ts` / legacy `zudoku.build.ts`). */
+export type ApitogoBuildConfig = BuildConfig;
+
+/**
+ * @deprecated Use {@link ApitogoBuildConfig} instead.
+ */
+export type ZudokuBuildConfig = BuildConfig;
+
+export type LoadedConfig = ConfigWithMeta;
+export type { ZudokuConfig as ApitogoConfig };
+export type {
+  ModulesConfig,
+  ResolvedModulesConfig,
+  ResolvedLandingContent,
+  ResolvedDashboardContent,
+  ResolvedProfileContent,
+  ResolvedPlansContent,
+  ResolvedLandingModule,
+  ResolvedUserPanelModule,
+  ResolvedDashboardModule,
+  ResolvedUserManagementModule,
+  ResolvedApiKeysModule,
+  ResolvedPlansModule,
+  DocsModuleConfig,
+  LandingModuleConfig,
+  LandingContentConfig,
+  LandingFeatureConfig,
+  LandingLinkConfig,
+  DashboardContentConfig,
+  ProfileContentConfig,
+  PlansContentConfig,
+  PlanTierConfig,
+  UserPanelModuleConfig,
+  DashboardModuleConfig,
+  UserManagementModuleConfig,
+  ApiKeysModuleConfig,
+  PlansModuleConfig,
+} from "./validators/ModulesSchema.js";
+
+export type ClerkAuthenticationConfig = Extract<
+  AuthenticationConfig,
+  { type: "clerk" }
+>;
+export type OpenIDAuthenticationConfig = Extract<
+  AuthenticationConfig,
+  { type: "openid" }
+>;
+export type Auth0AuthenticationConfig = Extract<
+  AuthenticationConfig,
+  { type: "auth0" }
+>;
+export type SupabaseAuthenticationConfig = Extract<
+  AuthenticationConfig,
+  { type: "supabase" }
+>;
+export type FirebaseAuthenticationConfig = Extract<
+  AuthenticationConfig,
+  { type: "firebase" }
+>;
+export type AzureB2CAuthenticationConfig = Extract<
+  AuthenticationConfig,
+  { type: "azureb2c" }
+>;

package/src/config/create-plugin.ts

@@ -0,0 +1,71 @@
+import {
+  isTransformConfigPlugin,
+  type ApitogoPlugin,
+} from "../lib/core/plugins.js";
+
+// Regex from stacktrace-parser for Node.js stack traces
+// https://github.com/errwischt/stacktrace-parser
+const NODE_STACK_REGEX =
+  /^\s*at (?:(?:\[object object\])?[^\\/]+(?: \[as \S+\])? )?\(?(.*?):(\d+)(?::(\d+))?\)?\s*$/i;
+
+const getCallerDir = () => {
+  const stack = new Error().stack;
+  if (!stack) return undefined;
+
+  // Stack frames: Error, getCallerDir, createPlugin, <caller>
+  const lines = stack.split("\n");
+  const callerLine = lines[3];
+  if (!callerLine) return undefined;
+
+  const match = callerLine.match(NODE_STACK_REGEX);
+  let filePath = match?.[1];
+  if (!filePath) return undefined;
+
+  if (filePath.startsWith("file://")) {
+    filePath = filePath.slice(7);
+  }
+
+  // Handle both forward and backslashes for cross-platform support
+  const lastSlash = Math.max(
+    filePath.lastIndexOf("/"),
+    filePath.lastIndexOf("\\"),
+  );
+  if (lastSlash === -1) return undefined;
+
+  return filePath.substring(0, lastSlash);
+};
+
+export const createPlugin = <TOptions extends unknown[]>(
+  factory: (...options: TOptions) => ApitogoPlugin,
+): ((...options: TOptions) => ApitogoPlugin) => {
+  const pluginDir = getCallerDir();
+
+  return (...options: TOptions) => {
+    const plugin = factory(...options);
+
+    if (!pluginDir) {
+      return plugin;
+    }
+
+    const originalTransformConfig = isTransformConfigPlugin(plugin)
+      ? plugin.transformConfig
+      : undefined;
+
+    return {
+      ...plugin,
+      transformConfig: async (context) => {
+        const result =
+          (await originalTransformConfig?.(context)) ?? context.config;
+
+        return {
+          ...result,
+          __pluginDirs: [
+            ...(context.config.__pluginDirs ?? []),
+            ...(result.__pluginDirs ?? []),
+            pluginDir,
+          ],
+        };
+      },
+    };
+  };
+};

package/src/config/file-exists.ts

@@ -0,0 +1,6 @@
+import { stat } from "node:fs/promises";
+
+export const fileExists = (path: string) =>
+  stat(path)
+    .then(() => true)
+    .catch(() => false);

package/src/config/loader.ts

@@ -0,0 +1,258 @@
+import { stat } from "node:fs/promises";
+import path from "node:path";
+import colors from "picocolors";
+import type { RollupOutput, RollupWatcher } from "rollup";
+import {
+  type ConfigEnv,
+  runnerImport,
+  loadEnv as viteLoadEnv,
+  type Plugin as VitePlugin,
+} from "vite";
+import { logger } from "../cli/common/logger.js";
+import { getZudokuRootDir } from "../cli/common/package-json.js";
+import { runPluginTransformConfig } from "../lib/core/transform-config.js";
+import invariant from "../lib/util/invariant.js";
+import { fileExists } from "./file-exists.js";
+import { resolveModulesConfig } from "./resolve-modules.js";
+import type { ResolvedModulesConfig } from "./validators/ModulesSchema.js";
+import type { ZudokuConfig } from "./validators/ZudokuConfig.js";
+import { validateConfig } from "./validators/ZudokuConfig.js";
+
+export type ConfigWithMeta = ZudokuConfig & {
+  __meta: {
+    rootDir: string;
+    moduleDir: string;
+    configPath: string;
+    mode: typeof process.env.ZUDOKU_ENV;
+    dependencies: string[];
+  };
+  __resolvedModules: ResolvedModulesConfig;
+};
+
+let config: ConfigWithMeta | undefined;
+let envPrefix: string[] | undefined;
+let publicEnv: Record<string, string> | undefined;
+let modifiedTimes: Map<string, number> | undefined;
+
+const zudokuConfigFiles = [
+  "apitogo.config.js",
+  "apitogo.config.jsx",
+  "apitogo.config.ts",
+  "apitogo.config.tsx",
+  "apitogo.config.mjs",
+  "zudoku.config.js",
+  "zudoku.config.jsx",
+  "zudoku.config.ts",
+  "zudoku.config.tsx",
+  "zudoku.config.mjs",
+];
+
+const serverConfigOutputFiles = ["apitogo.config.js", "zudoku.config.js"];
+
+async function getConfigFilePath(rootDir: string) {
+  for (const fileName of zudokuConfigFiles) {
+    const filepath = path.join(rootDir, fileName);
+    if (await fileExists(filepath)) {
+      return filepath;
+    }
+  }
+  throw new Error(`No APIToGo or Zudoku config file found in project root.`);
+}
+
+// Stub virtual modules so transitive imports don't fail during config loading.
+// The real Vite server replaces these with actual values at runtime.
+const virtualModuleStubPlugin: VitePlugin = {
+  name: "zudoku-virtual-module-stubs",
+  resolveId(id) {
+    if (id.startsWith("virtual:")) return `\0${id}`;
+  },
+  load(id) {
+    if (id.startsWith("\0virtual:")) return "export default {}";
+  },
+};
+
+async function loadZudokuConfigWithMeta(
+  rootDir: string,
+): Promise<ConfigWithMeta> {
+  const configPath = await getConfigFilePath(rootDir);
+
+  const { module, dependencies } = await runnerImport<{
+    default: ZudokuConfig;
+  }>(configPath, {
+    plugins: [virtualModuleStubPlugin],
+    environments: {
+      inline: {
+        resolve: {
+          // Prevent Node.js from trying to load apitogo's raw .ts source
+          // directly, which fails with ERR_UNSUPPORTED_NODE_MODULES_TYPE_STRIPPING
+          // when --experimental-strip-types is enabled. Uses regex to also
+          // catch plugins that re-export from apitogo (e.g. @zuplo/zudoku-plugin-*).
+          noExternal: [/apitogo/],
+        },
+      },
+    },
+    server: {
+      // this allows us to 'load' CSS files in the config
+      // see https://github.com/vitejs/vite/pull/19577
+      perEnvironmentStartEndDuringDev: true,
+    },
+  });
+
+  const config = module.default;
+
+  validateConfig(config, configPath);
+
+  const configWithMetadata: ConfigWithMeta = {
+    ...config,
+    __meta: {
+      rootDir,
+      moduleDir: getZudokuRootDir(),
+      mode: process.env.ZUDOKU_ENV,
+      dependencies,
+      configPath,
+    },
+    __resolvedModules: resolveModulesConfig(config),
+  };
+
+  return configWithMetadata;
+}
+
+export function findOutputPathOfServerConfig(
+  output: RollupOutput | RollupOutput[] | RollupWatcher,
+) {
+  if (Array.isArray(output)) {
+    throw new Error("Expected a single output, but got an array");
+  }
+  if ("output" in output) {
+    const result = output.output.find(
+      (o) =>
+        "isEntry" in o &&
+        o.isEntry &&
+        serverConfigOutputFiles.includes(o.fileName),
+    );
+    if (result) {
+      return result.fileName;
+    }
+  }
+  throw new Error("Could not find server config output file");
+}
+
+function loadEnv(configEnv: ConfigEnv, rootDir: string) {
+  const envPrefix = ["ZUPLO_PUBLIC_", "ZUDOKU_PUBLIC_"];
+  const localEnv = viteLoadEnv(configEnv.mode, rootDir, envPrefix);
+
+  process.env = { ...localEnv, ...process.env };
+
+  const publicEnv = Object.fromEntries(
+    Object.entries(process.env)
+      .filter(([key]) => envPrefix.some((prefix) => key.startsWith(prefix)))
+      .map(([key, value]) => [key, JSON.stringify(value)]),
+  );
+
+  return { publicEnv, envPrefix };
+}
+
+async function hasConfigChanged() {
+  if (!config || !modifiedTimes) return true;
+
+  const files = [config.__meta.configPath, ...config.__meta.dependencies];
+
+  try {
+    const hasChanged = await Promise.all(
+      files.map(async (depPath) => {
+        const depStat = await stat(depPath);
+        const cachedMtime = modifiedTimes?.get(depPath);
+        return !cachedMtime || depStat.mtimeMs !== cachedMtime;
+      }),
+    ).then((results) => results.some(Boolean));
+
+    return hasChanged;
+  } catch {
+    return true;
+  }
+}
+
+async function updateModifiedTimes() {
+  if (!config) return;
+
+  const files = [config.__meta.configPath, ...config.__meta.dependencies];
+
+  modifiedTimes = new Map();
+
+  await Promise.all(
+    files.map(async (depPath) => {
+      const depStat = await stat(depPath);
+      modifiedTimes?.set(depPath, depStat.mtimeMs);
+    }),
+  );
+}
+
+export const getCurrentConfig = () => {
+  invariant(config, "Config not loaded");
+  return config;
+};
+
+export const setCurrentConfig = (newConfig: ConfigWithMeta) => {
+  config = newConfig;
+};
+
+export async function loadZudokuConfig(
+  configEnv: ConfigEnv,
+  rootDir: string,
+): Promise<{
+  config: ConfigWithMeta;
+  envPrefix: string[];
+  publicEnv: Record<string, string>;
+}> {
+  const shouldReload = await hasConfigChanged();
+
+  if (!shouldReload && config && envPrefix && publicEnv) {
+    return { config, envPrefix, publicEnv };
+  }
+
+  ({ publicEnv, envPrefix } = loadEnv(configEnv, rootDir));
+
+  try {
+    const loadedConfig = await loadZudokuConfigWithMeta(rootDir);
+    const transformedConfig = await runPluginTransformConfig(loadedConfig);
+    config = {
+      ...transformedConfig,
+      __resolvedModules: resolveModulesConfig(transformedConfig),
+    };
+
+    if (!process.env.APITOGO_JSON_ONLY) {
+      logger.info(
+        colors.cyan(`loaded config file `) +
+          colors.dim(config.__meta.configPath),
+        { timestamp: true },
+      );
+    }
+
+    return { config, envPrefix, publicEnv };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+
+    if (config) {
+      // return the last valid config if it exists
+      return { config, envPrefix, publicEnv };
+    }
+
+    throw new Error(errorMessage, { cause: error });
+  } finally {
+    await updateModifiedTimes();
+  }
+}
+
+export const setStandaloneConfig = (rootDir: string) => {
+  const emptyConfig = {};
+  config = {
+    __meta: {
+      rootDir,
+      moduleDir: getZudokuRootDir(),
+      mode: "standalone",
+      dependencies: [],
+      configPath: "",
+    },
+    __resolvedModules: resolveModulesConfig(emptyConfig),
+  };
+};