zudoku 0.0.0-fix-firebase-export.f8270825 → 0.0.0-monetization-standalone.zd1543a39

package/src/lib/core/RouteGuard.tsx

@@ -27,16 +27,31 @@ export const RouteGuard = () => {
   const shouldBypass = use(BypassProtectedRoutesContext);
   const { protectedRoutes } = zudoku.options;
 
-  const authCheckFn =
-    !shouldBypass && protectedRoutes
-      ? Object.entries(protectedRoutes).find(([path]) =>
-          matchPath({ path, end: true }, location.pathname),
-        )?.[1]
-      : undefined;
+  const protectedRouteEntry = protectedRoutes
+    ? Object.entries(protectedRoutes).find(([path]) =>
+        matchPath({ path, end: true }, location.pathname),
+      )
+    : undefined;
 
-  const isProtectedRoute = authCheckFn !== undefined;
-  const needsToSignIn =
-    isProtectedRoute && !authCheckFn({ auth, context: zudoku });
+  const isProtectedRoute = protectedRouteEntry !== undefined;
+
+  // SSR/prerendering mode: render content with search meta tag, skip all auth
+  if (shouldBypass) {
+    return (
+      <>
+        {isProtectedRoute && (
+          <Helmet>
+            <meta
+              name="pagefind"
+              data-pagefind-filter={`section:${SEARCH_PROTECTED_SECTION}`}
+              content="true"
+            />
+          </Helmet>
+        )}
+        <Outlet />
+      </>
+    );
+  }
 
   if (isProtectedRoute && !auth.isAuthEnabled) {
     throw new ZudokuError("Authentication is not enabled", {
@@ -46,6 +61,10 @@ export const RouteGuard = () => {
     });
   }
 
+  const authCheckFn = protectedRouteEntry?.[1];
+  const needsToSignIn =
+    isProtectedRoute && !authCheckFn?.({ auth, context: zudoku });
+
   if (needsToSignIn && auth.isPending && typeof window !== "undefined") {
     return null;
   }
@@ -91,7 +110,7 @@ export const RouteGuard = () => {
                 )
               }
             >
-              Login{" "}
+              Login
             </Button>
           </DialogFooter>
         </DialogContent>
@@ -99,18 +118,5 @@ export const RouteGuard = () => {
     );
   }
 
-  return (
-    <>
-      {shouldBypass && isProtectedRoute && (
-        <Helmet>
-          <meta
-            name="pagefind"
-            data-pagefind-filter={`section:${SEARCH_PROTECTED_SECTION}`}
-            content="true"
-          />
-        </Helmet>
-      )}
-      <Outlet />
-    </>
-  );
+  return <Outlet />;
 };

package/src/lib/core/plugins.ts

@@ -3,6 +3,7 @@ import type { ReactNode } from "react";
 import type { Location, RouteObject } from "react-router";
 import type { Navigation } from "../../config/validators/NavigationSchema.js";
 import type { ProtectedRoutesInput } from "../../config/validators/ProtectedRoutesSchema.js";
+import type { ZudokuConfig } from "../../config/validators/validate.js";
 import type { AuthenticationPlugin } from "../authentication/authentication.js";
 import type { MdxComponentsType } from "../util/MdxComponents.js";
 import type {
@@ -18,7 +19,8 @@ export type ZudokuPlugin =
   | ApiIdentityPlugin
   | SearchProviderPlugin
   | EventConsumerPlugin
-  | AuthenticationPlugin;
+  | AuthenticationPlugin
+  | TransformConfigPlugin;
 
 export type { AuthenticationPlugin, RouteObject };
 
@@ -60,6 +62,19 @@ export type ProfileNavigationItem = {
   icon?: LucideIcon;
 };
 
+export interface ConfigHookContext {
+  mode: typeof process.env.ZUDOKU_ENV;
+  rootDir: string;
+  configPath: string;
+}
+
+export interface TransformConfigPlugin {
+  transformConfig?: (
+    config: ZudokuConfig,
+    ctx: ConfigHookContext,
+  ) => Partial<ZudokuConfig> | void | Promise<Partial<ZudokuConfig> | void>;
+}
+
 export interface CommonPlugin {
   initialize?: (
     context: ZudokuContext,
@@ -110,3 +125,8 @@ export const isApiIdentityPlugin = (
   obj: ZudokuPlugin,
 ): obj is ApiIdentityPlugin =>
   "getIdentities" in obj && typeof obj.getIdentities === "function";
+
+export const isTransformConfigPlugin = (
+  obj: ZudokuPlugin,
+): obj is TransformConfigPlugin =>
+  "transformConfig" in obj && typeof obj.transformConfig === "function";

package/src/lib/core/react-query.ts

@@ -0,0 +1 @@
+export * from "@tanstack/react-query";

package/src/lib/core/transform-config.ts

@@ -0,0 +1,29 @@
+import createDeepmerge from "@fastify/deepmerge";
+import type { ConfigWithMeta } from "../../config/loader.js";
+import { type ConfigHookContext, isTransformConfigPlugin } from "./plugins.js";
+
+const mergeConfig = createDeepmerge({
+  mergeArray: (opt) => (_, source) => opt.clone(source),
+});
+
+export const runTransformConfigHooks = async (
+  config: ConfigWithMeta,
+): Promise<ConfigWithMeta> => {
+  const ctx = {
+    mode: config.__meta.mode,
+    rootDir: config.__meta.rootDir,
+    configPath: config.__meta.configPath,
+  } satisfies ConfigHookContext;
+  const plugins = config.plugins ?? [];
+
+  let result = config;
+
+  for (const plugin of plugins.filter(isTransformConfigPlugin)) {
+    const partial = await plugin.transformConfig?.(result, ctx);
+    if (!partial) continue;
+
+    result = mergeConfig(result, partial) as ConfigWithMeta;
+  }
+
+  return result;
+};

package/src/lib/errors/ErrorAlert.tsx

@@ -1,4 +1,3 @@
-import { SyntaxHighlight } from "zudoku/ui/SyntaxHighlight.js";
 import { DeveloperHint } from "../components/DeveloperHint.js";
 import { Heading } from "../components/Heading.js";
 import { Typography } from "../components/Typography.js";
@@ -22,11 +21,7 @@ export function ErrorAlert({ error }: { error: unknown }) {
       Error: {message}
       {hint && <DeveloperHint className="mb-4">{hint}</DeveloperHint>}
       {stringError && (
-        <SyntaxHighlight
-          className="max-h-[400px] [&>pre]:p-4"
-          language="js"
-          code={stringError}
-        />
+        <pre className="max-h-[400px] [&>pre]:p-4">{stringError}</pre>
       )}
     </Typography>
   );

package/src/lib/errors/ErrorMessage.tsx

@@ -0,0 +1,38 @@
+import { Alert, AlertDescription, AlertTitle } from "zudoku/ui/Alert.js";
+import { SyntaxHighlight } from "zudoku/ui/SyntaxHighlight.js";
+import { DeveloperHint } from "../components/DeveloperHint.js";
+import { ZudokuError } from "../util/invariant.js";
+
+export function ErrorMessage({ error }: { error: unknown }) {
+  const message =
+    error instanceof Error ? error.message : "Something went wrong";
+
+  const showDeveloperHints = process.env.NODE_ENV === "development";
+
+  const hint = error instanceof ZudokuError ? error.developerHint : undefined;
+  const title =
+    error instanceof ZudokuError ? error.title : "Something went wrong";
+  const stack = error instanceof Error ? error.stack : undefined;
+  const cause = error instanceof Error ? error.cause : undefined;
+
+  const stringError = cause instanceof Error ? String(cause.stack) : stack;
+
+  return (
+    <>
+      <Alert variant="destructive">
+        <AlertTitle>{title}</AlertTitle>
+        <AlertDescription>{message}</AlertDescription>
+      </Alert>
+      {showDeveloperHints && hint && (
+        <DeveloperHint className="mb-4">{hint}</DeveloperHint>
+      )}
+      {showDeveloperHints && stringError && (
+        <SyntaxHighlight
+          className="max-h-[400px] [&>pre]:p-4"
+          language="js"
+          code={stringError}
+        />
+      )}
+    </>
+  );
+}

package/src/lib/oas/graphql/circular.test.ts

@@ -0,0 +1,186 @@
+import { describe, expect, it } from "vitest";
+import {
+  CIRCULAR_REF,
+  handleCircularRefs,
+  SCHEMA_REF_PREFIX,
+} from "./circular.js";
+
+describe("handleCircularRefs", () => {
+  it("should return primitives unchanged", () => {
+    expect(handleCircularRefs(null)).toBe(null);
+    expect(handleCircularRefs(undefined)).toBe(undefined);
+    expect(handleCircularRefs(42)).toBe(42);
+    expect(handleCircularRefs("hello")).toBe("hello");
+    expect(handleCircularRefs(true)).toBe(true);
+  });
+
+  it("should handle simple objects without refs", () => {
+    const obj = { type: "string", description: "A string" };
+    const result = handleCircularRefs(obj);
+    expect(result).toEqual(obj);
+  });
+
+  it("should handle arrays", () => {
+    const arr = [{ type: "string" }, { type: "number" }];
+    const result = handleCircularRefs(arr);
+    expect(result).toEqual(arr);
+  });
+
+  it("should detect true circular references via object identity", () => {
+    const obj: Record<string, unknown> = { type: "object" };
+    obj.self = obj;
+
+    const result = handleCircularRefs(obj);
+    expect(result.type).toBe("object");
+    expect(result.self).toContain(CIRCULAR_REF);
+  });
+
+  it("should detect circular refs via __$ref path", () => {
+    const inner = { __$ref: "#/components/schemas/Node", type: "object" };
+    const obj = {
+      __$ref: "#/components/schemas/Node",
+      type: "object",
+      properties: {
+        child: inner,
+      },
+    };
+    (inner as Record<string, unknown>).properties = { parent: obj };
+
+    const result = handleCircularRefs(obj);
+    expect(result.properties.child).toBe(
+      `${SCHEMA_REF_PREFIX}#/components/schemas/Node`,
+    );
+  });
+
+  // Regression test for #1869
+  it("should NOT mark sibling refs to the same schema as circular", () => {
+    const timestampSchema1 = {
+      __$ref: "#/components/schemas/timestamp",
+      type: "string",
+      format: "date-time",
+    };
+    const timestampSchema2 = {
+      __$ref: "#/components/schemas/timestamp",
+      type: "string",
+      format: "date-time",
+    };
+
+    const obj = {
+      type: "object",
+      properties: {
+        created_at: timestampSchema1,
+        updated_at: timestampSchema2,
+      },
+    };
+
+    const result = handleCircularRefs(obj);
+
+    expect(result.properties.created_at).toEqual({
+      __$ref: "#/components/schemas/timestamp",
+      type: "string",
+      format: "date-time",
+    });
+    expect(result.properties.updated_at).toEqual({
+      __$ref: "#/components/schemas/timestamp",
+      type: "string",
+      format: "date-time",
+    });
+  });
+
+  it("should allow same ref path in different branches of the tree", () => {
+    const obj = {
+      type: "object",
+      properties: {
+        user: {
+          type: "object",
+          properties: {
+            id: { __$ref: "#/components/schemas/identifier", type: "string" },
+            name: { type: "string" },
+          },
+        },
+        post: {
+          type: "object",
+          properties: {
+            id: { __$ref: "#/components/schemas/identifier", type: "string" },
+            title: { type: "string" },
+          },
+        },
+      },
+    };
+
+    const result = handleCircularRefs(obj);
+
+    expect(result.properties.user.properties.id.type).toBe("string");
+    expect(result.properties.post.properties.id.type).toBe("string");
+    expect(result.properties.user.properties.id).not.toBe(
+      expect.stringContaining(SCHEMA_REF_PREFIX),
+    );
+    expect(result.properties.post.properties.id).not.toBe(
+      expect.stringContaining(SCHEMA_REF_PREFIX),
+    );
+  });
+
+  it("should handle shared object instances (same object, multiple references)", () => {
+    const sharedSchema = { type: "string", description: "Shared" };
+    const obj = {
+      type: "object",
+      properties: { field1: sharedSchema, field2: sharedSchema },
+    };
+
+    const result = handleCircularRefs(obj);
+
+    expect(result.properties.field1).toEqual({
+      type: "string",
+      description: "Shared",
+    });
+    expect(result.properties.field2).toEqual({
+      type: "string",
+      description: "Shared",
+    });
+  });
+
+  it("should handle nested arrays with refs", () => {
+    const obj = {
+      type: "object",
+      allOf: [
+        { __$ref: "#/components/schemas/Base", type: "object" },
+        { type: "object", properties: { extra: { type: "string" } } },
+      ],
+    };
+
+    const result = handleCircularRefs(obj);
+
+    expect(result.allOf[0]).toEqual({
+      __$ref: "#/components/schemas/Base",
+      type: "object",
+    });
+  });
+
+  it("should deduplicate shared object instances with __$ref", () => {
+    const shared = { __$ref: "#/components/schemas/Foo", type: "string" };
+    const obj = { a: shared, b: shared };
+    const result = handleCircularRefs(obj);
+
+    expect(result.a).toEqual({
+      __$ref: "#/components/schemas/Foo",
+      type: "string",
+    });
+    expect(result.b).toBe(`${SCHEMA_REF_PREFIX}#/components/schemas/Foo`);
+  });
+
+  it("should mark circular ref with property name from path", () => {
+    const parent: Record<string, unknown> = {
+      type: "object",
+      properties: {} as Record<string, unknown>,
+    };
+    const child: Record<string, unknown> = {
+      type: "object",
+      properties: { back: parent },
+    };
+    (parent.properties as Record<string, unknown>).child = child;
+
+    const result = handleCircularRefs(parent);
+
+    expect(result.properties.child.properties.back).toContain(CIRCULAR_REF);
+  });
+});

package/src/lib/oas/graphql/circular.ts

@@ -3,6 +3,7 @@ import { GraphQLJSON } from "graphql-type-json";
 import type { RecordAny } from "../../util/traverse.js";
 
 export const CIRCULAR_REF = "$[Circular Reference]";
+export const SCHEMA_REF_PREFIX = "$ref:";
 
 const OPENAPI_PROPS = new Set([
   "properties",
@@ -13,19 +14,34 @@ const OPENAPI_PROPS = new Set([
   "oneOf",
 ]);
 
-const handleCircularRefs = (
+export const handleCircularRefs = (
   // biome-ignore lint/suspicious/noExplicitAny: Allow any type
   obj: any,
   visited = new WeakSet(),
   refs = new WeakMap(),
   path: string[] = [],
+  seenRefPaths = new Set<string>(),
   // biome-ignore lint/suspicious/noExplicitAny: Allow any type
 ): any => {
   if (obj === null || typeof obj !== "object") return obj;
 
+  const refPath = obj.__$ref;
+
+  // Check if this object has a __$ref marker (set during schema code generation)
+  // If we've already fully processed this ref path, return a reference marker
+  // instead of the full data to avoid JSON.stringify serializing duplicates
+  if (typeof refPath === "string" && seenRefPaths.has(refPath)) {
+    return SCHEMA_REF_PREFIX + refPath;
+  }
+
   if (visited.has(obj)) {
     const cached = refs.get(obj);
-    if (cached) return cached;
+    if (cached) {
+      return typeof refPath === "string"
+        ? // If already processed, return ref marker to avoid duplicate serialization
+          SCHEMA_REF_PREFIX + refPath
+        : cached;
+    }
     const circularProp = path.find((p) => !OPENAPI_PROPS.has(p)) || path[0];
 
     return [CIRCULAR_REF, circularProp].filter(Boolean).join(":");
@@ -33,19 +49,42 @@ const handleCircularRefs = (
 
   visited.add(obj);
 
+  // Add refPath BEFORE recursing to detect cycles within this branch
+  // This will be removed after processing to allow siblings with the same ref
+  if (typeof refPath === "string") {
+    seenRefPaths.add(refPath);
+  }
+
+  let result: RecordAny | RecordAny[];
   if (Array.isArray(obj)) {
-    const result = obj.map((item, index) =>
-      handleCircularRefs(item, visited, refs, [...path, index.toString()]),
+    result = obj.map((item, index) =>
+      handleCircularRefs(
+        item,
+        visited,
+        refs,
+        [...path, index.toString()],
+        seenRefPaths,
+      ),
     );
-    refs.set(obj, result);
-    return result;
+  } else {
+    result = {};
+    for (const [key, value] of Object.entries(obj)) {
+      result[key] = handleCircularRefs(
+        value,
+        visited,
+        refs,
+        [...path, key],
+        seenRefPaths,
+      );
+    }
   }
+  refs.set(obj, result);
 
-  const result: RecordAny = {};
-  for (const [key, value] of Object.entries(obj)) {
-    result[key] = handleCircularRefs(value, visited, refs, [...path, key]);
+  // Remove refPath after processing so sibling refs aren't incorrectly marked
+  if (typeof refPath === "string") {
+    seenRefPaths.delete(refPath);
   }
-  refs.set(obj, result);
+
   return result;
 };
 

package/src/lib/oas/graphql/index.ts

@@ -473,7 +473,9 @@ const OperationItem = builder
                     name,
                     ...(typeof value === "string" ? { value } : value),
                   }))
-                : [],
+                : content.example !== undefined
+                  ? [{ name: "", value: content.example }]
+                  : [],
               encoding: Object.entries(content.encoding ?? {}).map(
                 ([name, value]) => ({ name, ...value }),
               ),
@@ -490,7 +492,7 @@ const OperationItem = builder
               statusCode,
               description: response.description,
               content: Object.entries(response.content ?? {}).map(
-                ([mediaType, { schema, examples }]) => ({
+                ([mediaType, { schema, examples, example }]) => ({
                   mediaType,
                   schema,
                   examples: examples
@@ -498,7 +500,9 @@ const OperationItem = builder
                         name,
                         ...(typeof value === "string" ? { value } : value),
                       }))
-                    : [],
+                    : example !== undefined
+                      ? [{ name: "", value: example }]
+                      : [],
                 }),
               ),
               headers: response.headers,