@vexcms/next 0.1.0-alpha.2 → 0.1.0-alpha.21

package/dist/cache/createVexRevalidateRoute.d.ts

@@ -0,0 +1,88 @@
+import type { CollectionSlug, VexConfig, VexDocument, VexRevalidateResponse } from "@vexcms/core";
+import type { NextRequest } from "next/server";
+import { NextResponse } from "next/server";
+/** Props for {@link createVexRevalidateRoute}. */
+export interface CreateVexRevalidateRouteProps {
+    /**
+     * The resolved VexCMS config. Supplies `access` for the write-permission
+     * check and `routes.map` for target resolution.
+     */
+    config: VexConfig;
+    /**
+     * Resolves the authenticated user and active organization for the current
+     * request. Wire to `() => fetchAuthQuery(api.auth.api.getUserOrg, {})` — the
+     * same call the admin panel route already makes.
+     */
+    getAuth: () => Promise<{
+        organization?: Record<string, unknown>;
+        user: null | Record<string, unknown>;
+    }>;
+    /**
+     * Reads the caller's session token for the current request. Wire to the host
+     * app's `getToken` export (`convexBetterAuthNextJs`'s output, re-exported
+     * from e.g. `~/auth/server`). A falsy return means "no session".
+     */
+    getToken: () => Promise<null | string | undefined>;
+    /**
+     * Lists every document in a collection, for the collection-wide purge
+     * (`{ collection, all: true }`). Wire to a read through the app's own
+     * `publishedSlugs`-style query — the factory cannot know an app's generated
+     * Convex `api`, which is why this is injected like `getToken`/`getAuth`.
+     *
+     * Omit to leave the collection-wide branch unwired: it then purges nothing
+     * and reports that in `errors`, rather than silently succeeding.
+     */
+    listCollection?: (collection: CollectionSlug) => Promise<Partial<VexDocument>[]>;
+}
+/**
+ * Creates a Next.js route handler that purges the cached paths affected by a
+ * document write. The admin panel calls this via `useVexMutation` after every
+ * successful create/update/delete, same-origin, as a relative fetch — no URL
+ * config, no shared secret.
+ *
+ * **Session-authorized, not secret-authorized.** The caller is a signed-in
+ * admin, so this reuses `getToken`/`getAuth` exactly like the admin panel route
+ * does, rather than introducing an env var or a shared secret. There is no
+ * API-key fallback: a caller with no browser session cannot reach this route as
+ * designed.
+ *
+ * **Path-based, not tag-based.** `revalidatePath` is the only purge mechanism.
+ * `cacheComponents: true` — required for `cacheTag`/`revalidateTag` — is
+ * incompatible with the `dynamic`/`runtime` segment configs the auth and admin
+ * routes require (measured: 5 files fail to build with it enabled), so
+ * `revalidateTag` is not an option in this codebase. Do not "upgrade" this to
+ * tag-based revalidation without first removing that segment-config dependency
+ * everywhere.
+ *
+ * **Never fails the caller past authorization.** A missing session returns 401,
+ * a session without write permission 403, and an oversized `changes` batch 413
+ * — all three reject before any map work runs. Past that point the handler
+ * never throws or returns 5xx: an unconfigured map, a throwing map, or an
+ * individual `revalidatePath` failure all resolve to 200 with the failures
+ * reported in the body. A failed purge is a stale page; failing the endpoint
+ * would only teach the fire-and-forget caller to retry pointlessly.
+ *
+ * @param props - Config and the host app's auth accessors.
+ * @returns `{ POST }` — mount directly as the route module's named export.
+ *
+ * @example
+ * ```ts
+ * // app/api/vex/revalidate/route.ts
+ * import { api } from "@convex/_generated/api";
+ * import { createVexRevalidateRoute } from "@vexcms/next/cache";
+ * import { fetchAuthQuery, getToken } from "~/auth/server";
+ * import config from "~/vex.config";
+ *
+ * export const { POST } = createVexRevalidateRoute({
+ *   config,
+ *   getToken,
+ *   getAuth: () => fetchAuthQuery(api.auth.api.getUserOrg, {}),
+ * });
+ * ```
+ */
+export declare function createVexRevalidateRoute(props: CreateVexRevalidateRouteProps): {
+    POST: (request: NextRequest) => Promise<NextResponse<{
+        error: string;
+    } | VexRevalidateResponse>>;
+};
+//# sourceMappingURL=createVexRevalidateRoute.d.ts.map

package/dist/cache/createVexRevalidateRoute.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createVexRevalidateRoute.d.ts","sourceRoot":"","sources":["../../src/cache/createVexRevalidateRoute.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,cAAc,EAEd,SAAS,EACT,WAAW,EAIX,qBAAqB,EACtB,MAAM,cAAc,CAAC;AAQtB,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC/C,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAE3C,kDAAkD;AAClD,MAAM,WAAW,6BAA6B;IAC5C;;;OAGG;IACH,MAAM,EAAE,SAAS,CAAC;IAClB;;;;OAIG;IACH,OAAO,EAAE,MAAM,OAAO,CAAC;QACrB,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QACvC,IAAI,EAAE,IAAI,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;KACtC,CAAC,CAAC;IACH;;;;OAIG;IACH,QAAQ,EAAE,MAAM,OAAO,CAAC,IAAI,GAAG,MAAM,GAAG,SAAS,CAAC,CAAC;IACnD;;;;;;;;OAQG;IACH,cAAc,CAAC,EAAE,CAAC,UAAU,EAAE,cAAc,KAAK,OAAO,CAAC,OAAO,CAAC,WAAW,CAAC,EAAE,CAAC,CAAC;CAClF;AAoBD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,6BAA6B,GAAG;IAC9E,IAAI,EAAE,CAAC,OAAO,EAAE,WAAW,KAAK,OAAO,CAAC,YAAY,CAAC;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,GAAG,qBAAqB,CAAC,CAAC,CAAC;CAClG,CAiHA"}

package/dist/cache/createVexServerClient.d.ts

@@ -0,0 +1,31 @@
+import type { VexServerClientOptions, VexServerClient } from "./types";
+/**
+ * Creates a server-only Convex read client safe to use in prerenderable
+ * Next.js routes.
+ *
+ * Wraps `ConvexHttpClient` from `convex/browser` instead of `convex/nextjs`'s
+ * `fetchQuery`, which hard-codes `client.setFetchOptions({ cache: "no-store" })`
+ * — the reason every route calling it builds dynamic (`ƒ`). This client never
+ * sets that option, so a route calling only `query()` can be prerendered and
+ * governed by the route's own `export const revalidate`.
+ *
+ * Every `query()` call is deduped via `React.cache` for the lifetime of one
+ * request: two identical `(query, args)` calls — e.g. `generateMetadata` and
+ * its page both reading the same document — resolve from a single Convex round
+ * trip instead of two.
+ *
+ * `React.cache` is instantiated fresh inside every `createVexServerClient()`
+ * call, so that dedupe only holds across calls sharing the SAME client
+ * instance — two clients built in two different modules cannot share a round
+ * trip even when they read identical `(query, args)`. Each app therefore
+ * creates exactly one instance, exported from its own `src/lib/vex.ts`, and
+ * every route or component imports that shared `vex` rather than calling
+ * `createVexServerClient()` itself.
+ *
+ * @param props - Client configuration.
+ * @returns A {@link VexServerClient} whose `query` method is deduped per request.
+ * @throws {Error} When no `url` is given and `process.env.NEXT_PUBLIC_CONVEX_URL`
+ *   is unset.
+ */
+export declare function createVexServerClient(props?: VexServerClientOptions): VexServerClient;
+//# sourceMappingURL=createVexServerClient.d.ts.map

package/dist/cache/createVexServerClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createVexServerClient.d.ts","sourceRoot":"","sources":["../../src/cache/createVexServerClient.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,sBAAsB,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAEvE;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,GAAE,sBAA2B,GAAG,eAAe,CA2BzF"}

package/dist/cache/index.d.ts

@@ -0,0 +1,5 @@
+export { createVexRevalidateRoute } from "./createVexRevalidateRoute";
+export type { CreateVexRevalidateRouteProps } from "./createVexRevalidateRoute";
+export { createVexServerClient } from "./createVexServerClient";
+export type { VexServerClientOptions, VexServerClient, } from "./types";
+//# sourceMappingURL=index.d.ts.map

package/dist/cache/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/cache/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,wBAAwB,EAAE,MAAM,4BAA4B,CAAC;AACtE,YAAY,EAAE,6BAA6B,EAAE,MAAM,4BAA4B,CAAC;AAChF,OAAO,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAOhE,YAAY,EACV,sBAAsB,EACtB,eAAe,GAChB,MAAM,SAAS,CAAC"}

package/dist/cache/index.js

@@ -0,0 +1,9 @@
+import {
+  createVexRevalidateRoute,
+  createVexServerClient
+} from "../chunk-3J7LCKFC.js";
+export {
+  createVexRevalidateRoute,
+  createVexServerClient
+};
+//# sourceMappingURL=index.js.map

package/dist/cache/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/cache/types.d.ts

@@ -0,0 +1,36 @@
+import type { FunctionReference, FunctionReturnType, OptionalRestArgs } from "convex/server";
+/**
+ * Construction options for {@link createVexServerClient}.
+ *
+ * Nothing here configures caching — the client's only cache behaviour is that
+ * it never sets `cache: "no-store"` and dedupes per request via `React.cache`.
+ * Cache *policy* lives where Next requires it: `export const revalidate` in
+ * each route.
+ */
+export interface VexServerClientOptions {
+    /**
+     * Skip Convex's deployment URL format check — for self-hosted backends whose
+     * URL does not match `https://<name>.convex.cloud`.
+     */
+    skipConvexDeploymentUrlCheck?: boolean;
+    /** Convex deployment URL. Defaults to `process.env.NEXT_PUBLIC_CONVEX_URL`. */
+    url?: string;
+}
+/**
+ * Server-only Convex read client returned by {@link createVexServerClient}.
+ *
+ * Exposes only `query` — this client is for prerenderable read paths, and it
+ * never sets `cache: "no-store"`, unlike `convex/nextjs`'s `fetchQuery`.
+ */
+export interface VexServerClient {
+    /**
+     * Runs a Convex query, deduped via `React.cache` for the lifetime of one
+     * request when called again with the same function reference and args.
+     *
+     * @param query - The Convex query function reference to call.
+     * @param args - Arguments for `query`, per Convex's `OptionalRestArgs`.
+     * @returns The query's resolved return value.
+     */
+    query<Query extends FunctionReference<"query">>(query: Query, ...args: OptionalRestArgs<Query>): Promise<FunctionReturnType<Query>>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/cache/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/cache/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAE7F;;;;;;;GAOG;AACH,MAAM,WAAW,sBAAsB;IACrC;;;OAGG;IACH,4BAA4B,CAAC,EAAE,OAAO,CAAC;IACvC,+EAA+E;IAC/E,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAED;;;;;GAKG;AACH,MAAM,WAAW,eAAe;IAC9B;;;;;;;OAOG;IACH,KAAK,CAAC,KAAK,SAAS,iBAAiB,CAAC,OAAO,CAAC,EAC5C,KAAK,EAAE,KAAK,EACZ,GAAG,IAAI,EAAE,gBAAgB,CAAC,KAAK,CAAC,GAC/B,OAAO,CAAC,kBAAkB,CAAC,KAAK,CAAC,CAAC,CAAC;CACvC"}

package/dist/chunk-3J7LCKFC.js

@@ -0,0 +1,129 @@
+// src/cache/createVexRevalidateRoute.ts
+import {
+  hasPermission,
+  PERMISSION_SCOPES,
+  resolveTargets,
+  VEX_REVALIDATE_BATCH_SIZE
+} from "@vexcms/core";
+import { revalidatePath } from "next/cache";
+import { NextResponse } from "next/server";
+function toCrudAction(operation) {
+  if (operation === "remove") return "delete";
+  if (operation === "upsert") return "update";
+  return operation;
+}
+function createVexRevalidateRoute(props) {
+  return {
+    async POST(request) {
+      const token = await props.getToken();
+      if (token === null || token === void 0 || token === "") {
+        return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
+      }
+      let body;
+      try {
+        body = await request.json();
+      } catch {
+        return NextResponse.json({ error: "Bad Request" }, { status: 400 });
+      }
+      const { organization, user } = await props.getAuth();
+      const operation = "all" in body ? "update" : body.operation;
+      const action = toCrudAction(operation);
+      const allowed = hasPermission({
+        access: props.config.access,
+        action,
+        organization,
+        resource: body.collection,
+        user,
+        // A purge writes no document fields — this asks whether the caller
+        // may act on the collection at all, not against a specific payload.
+        scope: PERMISSION_SCOPES.any
+      });
+      if (!allowed) {
+        return NextResponse.json({ error: "Forbidden" }, { status: 403 });
+      }
+      const errors = [];
+      let changes;
+      if ("all" in body) {
+        if (props.listCollection === void 0) {
+          errors.push(
+            new Error(
+              "createVexRevalidateRoute: a collection-wide purge was requested but `listCollection` is not wired"
+            )
+          );
+          changes = [];
+        } else {
+          try {
+            const docs = await props.listCollection(body.collection);
+            changes = docs.map((doc) => ({ after: doc }));
+          } catch (error) {
+            errors.push(error);
+            changes = [];
+          }
+        }
+      } else {
+        changes = body.changes;
+        if (changes.length > VEX_REVALIDATE_BATCH_SIZE) {
+          return NextResponse.json(
+            {
+              error: `Cannot revalidate more than ${VEX_REVALIDATE_BATCH_SIZE} changes in a single request`
+            },
+            { status: 413 }
+          );
+        }
+      }
+      const routesConfig = props.config.routes;
+      if (routesConfig === void 0) {
+        return NextResponse.json({ errors, revalidated: [] }, { status: 200 });
+      }
+      const pool = [];
+      for (const change of changes) {
+        const target = resolveTargets({
+          after: change.after,
+          before: change.before,
+          collection: body.collection,
+          map: routesConfig.map,
+          operation: action
+        });
+        pool.push(...target.paths);
+        errors.push(...target.errors);
+      }
+      const revalidated = [];
+      for (const path of new Set(pool)) {
+        try {
+          revalidatePath(path);
+          revalidated.push(path);
+        } catch (error) {
+          errors.push(error);
+        }
+      }
+      return NextResponse.json({ errors, revalidated }, { status: 200 });
+    }
+  };
+}
+
+// src/cache/createVexServerClient.ts
+import { ConvexHttpClient } from "convex/browser";
+import { cache } from "react";
+function createVexServerClient(props = {}) {
+  const url = props.url ?? process.env.NEXT_PUBLIC_CONVEX_URL;
+  if (url === void 0 || url === "") {
+    throw new Error(
+      "createVexServerClient: no Convex deployment URL. Pass `url`, or set NEXT_PUBLIC_CONVEX_URL."
+    );
+  }
+  const client = new ConvexHttpClient(url, {
+    skipConvexDeploymentUrlCheck: props.skipConvexDeploymentUrlCheck
+  });
+  const cachedQuery = cache(
+    async (query, args) => client.query(query, args)
+  );
+  return {
+    query: async (query, ...args) => cachedQuery(query, args[0] ?? {})
+  };
+}
+
+export {
+  createVexRevalidateRoute,
+  createVexServerClient
+};
+//# sourceMappingURL=chunk-3J7LCKFC.js.map

package/dist/chunk-3J7LCKFC.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/cache/createVexRevalidateRoute.ts","../src/cache/createVexServerClient.ts"],"sourcesContent":["import type {\n  CollectionSlug,\n  CrudWriteAction,\n  VexConfig,\n  VexDocument,\n  VexMutationOperation,\n  VexRevalidateChange,\n  VexRevalidateRequest,\n  VexRevalidateResponse,\n} from \"@vexcms/core\";\nimport {\n  hasPermission,\n  PERMISSION_SCOPES,\n  resolveTargets,\n  VEX_REVALIDATE_BATCH_SIZE,\n} from \"@vexcms/core\";\nimport { revalidatePath } from \"next/cache\";\nimport type { NextRequest } from \"next/server\";\nimport { NextResponse } from \"next/server\";\n\n/** Props for {@link createVexRevalidateRoute}. */\nexport interface CreateVexRevalidateRouteProps {\n  /**\n   * The resolved VexCMS config. Supplies `access` for the write-permission\n   * check and `routes.map` for target resolution.\n   */\n  config: VexConfig;\n  /**\n   * Resolves the authenticated user and active organization for the current\n   * request. Wire to `() => fetchAuthQuery(api.auth.api.getUserOrg, {})` — the\n   * same call the admin panel route already makes.\n   */\n  getAuth: () => Promise<{\n    organization?: Record<string, unknown>;\n    user: null | Record<string, unknown>;\n  }>;\n  /**\n   * Reads the caller's session token for the current request. Wire to the host\n   * app's `getToken` export (`convexBetterAuthNextJs`'s output, re-exported\n   * from e.g. `~/auth/server`). A falsy return means \"no session\".\n   */\n  getToken: () => Promise<null | string | undefined>;\n  /**\n   * Lists every document in a collection, for the collection-wide purge\n   * (`{ collection, all: true }`). Wire to a read through the app's own\n   * `publishedSlugs`-style query — the factory cannot know an app's generated\n   * Convex `api`, which is why this is injected like `getToken`/`getAuth`.\n   *\n   * Omit to leave the collection-wide branch unwired: it then purges nothing\n   * and reports that in `errors`, rather than silently succeeding.\n   */\n  listCollection?: (collection: CollectionSlug) => Promise<Partial<VexDocument>[]>;\n}\n\n/**\n * Maps the wire verb to the CRUD action `hasPermission` and `resolveTargets`\n * accept.\n *\n * `VexMutationOperation` is named for the `vexConvexApi` function that produced\n * the write (`vexConvexApi.remove`), while `hasPermission` only accepts\n * `CRUD_ACTIONS`. Mapping happens exactly once per request so the same value\n * drives both the permission check and target resolution.\n *\n * @param operation - The wire operation from the request body.\n * @returns The equivalent CRUD action.\n */\nfunction toCrudAction(operation: VexMutationOperation): CrudWriteAction {\n  if (operation === \"remove\") return \"delete\";\n  if (operation === \"upsert\") return \"update\";\n  return operation;\n}\n\n/**\n * Creates a Next.js route handler that purges the cached paths affected by a\n * document write. The admin panel calls this via `useVexMutation` after every\n * successful create/update/delete, same-origin, as a relative fetch — no URL\n * config, no shared secret.\n *\n * **Session-authorized, not secret-authorized.** The caller is a signed-in\n * admin, so this reuses `getToken`/`getAuth` exactly like the admin panel route\n * does, rather than introducing an env var or a shared secret. There is no\n * API-key fallback: a caller with no browser session cannot reach this route as\n * designed.\n *\n * **Path-based, not tag-based.** `revalidatePath` is the only purge mechanism.\n * `cacheComponents: true` — required for `cacheTag`/`revalidateTag` — is\n * incompatible with the `dynamic`/`runtime` segment configs the auth and admin\n * routes require (measured: 5 files fail to build with it enabled), so\n * `revalidateTag` is not an option in this codebase. Do not \"upgrade\" this to\n * tag-based revalidation without first removing that segment-config dependency\n * everywhere.\n *\n * **Never fails the caller past authorization.** A missing session returns 401,\n * a session without write permission 403, and an oversized `changes` batch 413\n * — all three reject before any map work runs. Past that point the handler\n * never throws or returns 5xx: an unconfigured map, a throwing map, or an\n * individual `revalidatePath` failure all resolve to 200 with the failures\n * reported in the body. A failed purge is a stale page; failing the endpoint\n * would only teach the fire-and-forget caller to retry pointlessly.\n *\n * @param props - Config and the host app's auth accessors.\n * @returns `{ POST }` — mount directly as the route module's named export.\n *\n * @example\n * ```ts\n * // app/api/vex/revalidate/route.ts\n * import { api } from \"@convex/_generated/api\";\n * import { createVexRevalidateRoute } from \"@vexcms/next/cache\";\n * import { fetchAuthQuery, getToken } from \"~/auth/server\";\n * import config from \"~/vex.config\";\n *\n * export const { POST } = createVexRevalidateRoute({\n *   config,\n *   getToken,\n *   getAuth: () => fetchAuthQuery(api.auth.api.getUserOrg, {}),\n * });\n * ```\n */\nexport function createVexRevalidateRoute(props: CreateVexRevalidateRouteProps): {\n  POST: (request: NextRequest) => Promise<NextResponse<{ error: string } | VexRevalidateResponse>>;\n} {\n  return {\n    async POST(\n      request: NextRequest,\n    ): Promise<NextResponse<{ error: string } | VexRevalidateResponse>> {\n      const token = await props.getToken();\n      if (token === null || token === undefined || token === \"\") {\n        return NextResponse.json({ error: \"Unauthorized\" }, { status: 401 });\n      }\n\n      let body: VexRevalidateRequest;\n      try {\n        body = (await request.json()) as VexRevalidateRequest;\n      } catch {\n        return NextResponse.json({ error: \"Bad Request\" }, { status: 400 });\n      }\n\n      const { organization, user } = await props.getAuth();\n\n      // One mapping, used for BOTH the permission check and target resolution.\n      const operation: VexMutationOperation = \"all\" in body ? \"update\" : body.operation;\n      const action = toCrudAction(operation);\n\n      const allowed = hasPermission({\n        access: props.config.access,\n        action,\n        organization,\n        resource: body.collection,\n        user,\n        // A purge writes no document fields — this asks whether the caller\n        // may act on the collection at all, not against a specific payload.\n        scope: PERMISSION_SCOPES.any,\n      });\n      if (!allowed) {\n        return NextResponse.json({ error: \"Forbidden\" }, { status: 403 });\n      }\n\n      const errors: unknown[] = [];\n      let changes: VexRevalidateChange[];\n\n      if (\"all\" in body) {\n        // Server-derived, so no client-supplied batch to bound. Each document\n        // is mapped as its current state.\n        if (props.listCollection === undefined) {\n          errors.push(\n            new Error(\n              \"createVexRevalidateRoute: a collection-wide purge was requested but `listCollection` is not wired\",\n            ),\n          );\n          changes = [];\n        } else {\n          try {\n            const docs = await props.listCollection(body.collection);\n            changes = docs.map((doc) => ({ after: doc }));\n          } catch (error) {\n            // An unreachable deployment must not 500 a purge request.\n            errors.push(error);\n            changes = [];\n          }\n        }\n      } else {\n        changes = body.changes;\n        if (changes.length > VEX_REVALIDATE_BATCH_SIZE) {\n          return NextResponse.json(\n            {\n              error: `Cannot revalidate more than ${VEX_REVALIDATE_BATCH_SIZE} changes in a single request`,\n            },\n            { status: 413 },\n          );\n        }\n      }\n\n      const routesConfig = props.config.routes;\n      if (routesConfig === undefined) {\n        // A project with no route map still gets a working, harmless\n        // endpoint rather than a 500. Any error already accumulated (e.g. an\n        // unwired collection-wide purge) is still reported.\n        return NextResponse.json({ errors, revalidated: [] }, { status: 200 });\n      }\n\n      const pool: string[] = [];\n\n      for (const change of changes) {\n        // A throwing map is contained inside `resolveTargets` — its failure\n        // lands in that call's `errors` and never propagates here.\n        const target = resolveTargets({\n          after: change.after,\n          before: change.before,\n          collection: body.collection,\n          map: routesConfig.map,\n          operation: action,\n        });\n        pool.push(...target.paths);\n        errors.push(...target.errors);\n      }\n\n      // Dedupe across the whole batch, preserving first-seen order — the same\n      // contract `resolveTargets` applies to one document's before/after.\n      const revalidated: string[] = [];\n      for (const path of new Set(pool)) {\n        try {\n          revalidatePath(path);\n          revalidated.push(path);\n        } catch (error) {\n          // `revalidatePath` is a Next API called here, so it is not covered by\n          // `resolveTargets`' containment.\n          errors.push(error);\n        }\n      }\n\n      return NextResponse.json({ errors, revalidated }, { status: 200 });\n    },\n  };\n}\n","import type { FunctionReference, OptionalRestArgs } from \"convex/server\";\n\nimport { ConvexHttpClient } from \"convex/browser\";\nimport { cache } from \"react\";\n\nimport type { VexServerClientOptions, VexServerClient } from \"./types\";\n\n/**\n * Creates a server-only Convex read client safe to use in prerenderable\n * Next.js routes.\n *\n * Wraps `ConvexHttpClient` from `convex/browser` instead of `convex/nextjs`'s\n * `fetchQuery`, which hard-codes `client.setFetchOptions({ cache: \"no-store\" })`\n * — the reason every route calling it builds dynamic (`ƒ`). This client never\n * sets that option, so a route calling only `query()` can be prerendered and\n * governed by the route's own `export const revalidate`.\n *\n * Every `query()` call is deduped via `React.cache` for the lifetime of one\n * request: two identical `(query, args)` calls — e.g. `generateMetadata` and\n * its page both reading the same document — resolve from a single Convex round\n * trip instead of two.\n *\n * `React.cache` is instantiated fresh inside every `createVexServerClient()`\n * call, so that dedupe only holds across calls sharing the SAME client\n * instance — two clients built in two different modules cannot share a round\n * trip even when they read identical `(query, args)`. Each app therefore\n * creates exactly one instance, exported from its own `src/lib/vex.ts`, and\n * every route or component imports that shared `vex` rather than calling\n * `createVexServerClient()` itself.\n *\n * @param props - Client configuration.\n * @returns A {@link VexServerClient} whose `query` method is deduped per request.\n * @throws {Error} When no `url` is given and `process.env.NEXT_PUBLIC_CONVEX_URL`\n *   is unset.\n */\nexport function createVexServerClient(props: VexServerClientOptions = {}): VexServerClient {\n  const url = props.url ?? process.env.NEXT_PUBLIC_CONVEX_URL;\n  if (url === undefined || url === \"\") {\n    throw new Error(\n      \"createVexServerClient: no Convex deployment URL. Pass `url`, or set NEXT_PUBLIC_CONVEX_URL.\",\n    );\n  }\n\n  const client = new ConvexHttpClient(url, {\n    skipConvexDeploymentUrlCheck: props.skipConvexDeploymentUrlCheck,\n  });\n\n  // Deliberately NOT `client.setFetchOptions({ cache: \"no-store\" })` — that is\n  // exactly what `convex/nextjs`'s `fetchQuery` does and what forces every\n  // consuming route dynamic.\n\n  // `React.cache` keys on the argument list, so the entry is (query reference,\n  // args) — never the reference alone. Args are normalised to a single value so\n  // `query(fn)` and `query(fn, {})` share one entry.\n  const cachedQuery = cache(\n    async (query: FunctionReference<\"query\">, args: unknown): Promise<unknown> =>\n      client.query(query, args as OptionalRestArgs<FunctionReference<\"query\">>[0]),\n  );\n\n  return {\n    query: async (query, ...args) => cachedQuery(query, args[0] ?? {}),\n  };\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-K4AAS5B5.js

@@ -0,0 +1,22 @@
+// src/NextAdminLayout.tsx
+import { NextAdminLayoutClient } from "./NextAdminLayoutClient";
+import { cookies } from "next/headers";
+import { jsx } from "react/jsx-runtime";
+async function NextAdminLayout(props) {
+  const cookieStore = await cookies();
+  const sidebarOpen = String(cookieStore.get("sidebar_state")?.value) === "true";
+  return /* @__PURE__ */ jsx(
+    NextAdminLayoutClient,
+    {
+      user: props.user,
+      organization: props.organization,
+      sidebarOpen,
+      children: props.children
+    }
+  );
+}
+
+export {
+  NextAdminLayout
+};
+//# sourceMappingURL=chunk-K4AAS5B5.js.map

package/dist/chunk-K4AAS5B5.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/NextAdminLayout.tsx"],"sourcesContent":["import type { ReactNode } from \"react\";\nimport type { AdminUser } from \"@vexcms/react\";\nimport { NextAdminLayoutClient } from \"./NextAdminLayoutClient\";\nimport { cookies } from \"next/headers\";\n\n/**\n * Next.js admin layout shell for VexCMS.\n *\n * A **server component** that reads the `sidebar_state` cookie server-side\n * (so the sidebar's open/closed state is correct on first paint, with no\n * client flash) and passes it, plus `user`/`organization`/`children`, to the\n * client leaf `NextAdminLayoutClient`. Config no longer crosses this\n * boundary at all — the admin panel's client tree gets its config from the\n * app's own `VexConfigProvider` mount (`clientProviders.tsx`), not from a\n * prop threaded through this layout.\n *\n * Render it from your admin `layout.tsx`. Because this is a server component,\n * your `layout.tsx` may itself be an `async` server component (e.g. to run auth\n * checks).\n *\n * @param props - Layout props.\n * @param props.children - The page content from `[[...slug]]/page.tsx`.\n * @param props.user - Current user for the admin shell.\n * @returns The rendered admin shell, wrapping `children` in the client boundary\n *   ({@link NextAdminLayoutClient}) with the server-read sidebar cookie state.\n * @example\n * ```tsx\n * // app/admin/layout.tsx\n * import { NextAdminLayout } from \"@vexcms/next/client\";\n * import { getCurrentUser } from \"~/auth/serverUtils\";\n *\n * export default async function AdminLayout({ children }: { children: ReactNode }) {\n *   const user = await getCurrentUser();\n *   return (\n *     <NextAdminLayout user={user ?? undefined}>\n *       {children}\n *     </NextAdminLayout>\n *   );\n * }\n * ```\n */\nexport async function NextAdminLayout(props: {\n  children: ReactNode;\n  user?: AdminUser;\n  organization?: Record<string, unknown>;\n}) {\n  const cookieStore = await cookies();\n  const sidebarOpen = String(cookieStore.get(\"sidebar_state\")?.value) === \"true\";\n\n  return (\n    <NextAdminLayoutClient\n      user={props.user}\n      organization={props.organization}\n      sidebarOpen={sidebarOpen}\n    >\n      {props.children}\n    </NextAdminLayoutClient>\n  );\n}\n"],"mappings":";AAEA,SAAS,6BAA6B;AACtC,SAAS,eAAe;AA+CpB;AATJ,eAAsB,gBAAgB,OAInC;AACD,QAAM,cAAc,MAAM,QAAQ;AAClC,QAAM,cAAc,OAAO,YAAY,IAAI,eAAe,GAAG,KAAK,MAAM;AAExE,SACE;AAAA,IAAC;AAAA;AAAA,MACC,MAAM,MAAM;AAAA,MACZ,cAAc,MAAM;AAAA,MACpB;AAAA,MAEC,gBAAM;AAAA;AAAA,EACT;AAEJ;","names":[]}

package/dist/chunk-KIRSFMPI.js

@@ -0,0 +1,78 @@
+// src/seo/createVexRobots.ts
+function createVexRobots(props) {
+  return function robots() {
+    const disallow = props.disallow ?? [];
+    return {
+      rules: {
+        allow: "/",
+        userAgent: "*",
+        ...disallow.length === 0 ? {} : { disallow }
+      },
+      sitemap: `${props.siteUrl}/sitemap.xml`
+    };
+  };
+}
+
+// src/seo/createVexSitemap.ts
+function createVexSitemap(props) {
+  return async function sitemap() {
+    try {
+      const items = await props.client.query(props.query, props.args ?? {});
+      if (!Array.isArray(items)) {
+        return [];
+      }
+      const { getUpdatedAt } = props;
+      return items.map((item) => {
+        const updatedAt = getUpdatedAt?.(item);
+        return {
+          url: props.toUrl(props.getSlug(item)),
+          ...typeof updatedAt === "number" && Number.isFinite(updatedAt) ? { lastModified: new Date(updatedAt) } : {}
+        };
+      });
+    } catch {
+      return [];
+    }
+  };
+}
+
+// src/seo/vexMetadata.ts
+function vexMetadata(props) {
+  return {
+    alternates: { canonical: props.path },
+    description: props.description,
+    metadataBase: new URL(props.siteUrl),
+    // `openGraph` is ALWAYS emitted. Gating the whole block on an image is the
+    // defect Step 1 fixed in `apps/www/src/lib/metadata.ts`: a page with no
+    // uploaded image published no `og:title` and no `og:description` at all.
+    // Only `images` is conditional.
+    openGraph: {
+      description: props.description,
+      title: props.title,
+      ...props.imageUrl === void 0 || props.imageUrl === "" ? {} : { images: [{ url: props.imageUrl }] }
+    },
+    title: props.title
+  };
+}
+
+// src/seo/vexStaticParams.ts
+async function vexStaticParams(props) {
+  try {
+    const items = await props.client.query(props.query, props.args ?? {});
+    if (!Array.isArray(items)) {
+      return [];
+    }
+    return items.map((item) => ({
+      [props.paramName]: props.getSlug(item)
+    }));
+  } catch {
+    return [];
+  }
+}
+
+export {
+  createVexRobots,
+  createVexSitemap,
+  vexMetadata,
+  vexStaticParams
+};
+//# sourceMappingURL=chunk-KIRSFMPI.js.map

package/dist/chunk-KIRSFMPI.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/seo/createVexRobots.ts","../src/seo/createVexSitemap.ts","../src/seo/vexMetadata.ts","../src/seo/vexStaticParams.ts"],"sourcesContent":["import type { MetadataRoute } from \"next\";\n\n/**\n * Creates a Next.js `robots.ts` default export that allows crawlers across the\n * site and points them at the generated sitemap.\n *\n * @param props - Robots configuration.\n * @returns A `robots()` function suitable as `app/robots.ts`'s default export.\n */\nexport function createVexRobots(props: {\n  /**\n   * Paths to disallow. Every vexcms template passes `[\"/admin\", \"/api\"]` — the\n   * admin panel is authenticated and neither belongs in an index. Omitted\n   * entirely when absent or empty, rather than emitted as an empty array.\n   */\n  disallow?: string[];\n  /**\n   * The site's absolute origin, no trailing slash (e.g. `https://example.com`).\n   * The sitemap URL is derived as `${siteUrl}/sitemap.xml`.\n   */\n  siteUrl: string;\n}): () => MetadataRoute.Robots {\n  return function robots(): MetadataRoute.Robots {\n    const disallow = props.disallow ?? [];\n    return {\n      rules: {\n        allow: \"/\",\n        userAgent: \"*\",\n        ...(disallow.length === 0 ? {} : { disallow }),\n      },\n      sitemap: `${props.siteUrl}/sitemap.xml`,\n    };\n  };\n}\n","import type { FunctionReference, FunctionReturnType, OptionalRestArgs } from \"convex/server\";\nimport type { MetadataRoute } from \"next\";\n\nimport type { VexServerClient } from \"../cache/types\";\n\ntype ArrayItem<T> = T extends (infer Item)[] ? Item : never;\n\n/**\n * Creates a Next.js `sitemap.ts` default export from a Convex published-slugs\n * query (`packages/core/src/api/publishedSlugs/server.ts`).\n *\n * Tolerates an unreachable Convex deployment (P-020): a read failure returns\n * `[]` — an empty sitemap — rather than failing the build.\n *\n * @param props - Sitemap configuration.\n * @returns A `sitemap()` function suitable as `app/sitemap.ts`'s default export.\n */\nexport function createVexSitemap<Query extends FunctionReference<\"query\">>(props: {\n  args?: OptionalRestArgs<Query>[0];\n  client: VexServerClient;\n  getSlug: (item: ArrayItem<FunctionReturnType<Query>>) => string;\n  /**\n   * Optional last-modified extractor. Omit it when the collection carries no\n   * modification timestamp — Convex's `_creationTime` is set at insert and\n   * never moves, so reporting it as `lastModified` would be a lie.\n   * `lastModified` is optional in the sitemap protocol; an absent value is\n   * correct, a wrong one costs crawl budget.\n   *\n   * May return `undefined` for an individual item, and that is the common\n   * case: `defineCollection` injects `updatedAt` on every content collection,\n   * but only a write through `create`/`update` populates it — a seeded or\n   * imported row has none. Those entries are emitted with no `lastModified`\n   * rather than an `Invalid Date`.\n   */\n  getUpdatedAt?: (item: ArrayItem<FunctionReturnType<Query>>) => number | undefined;\n  /**\n   * Maps one item's slug to its absolute public URL — the route mapper, so URL\n   * shape (e.g. `/blog/[slug]` vs `/[slug]`) is the caller's choice.\n   */\n  toUrl: (slug: string) => string;\n  query: Query;\n}): () => Promise<MetadataRoute.Sitemap> {\n  return async function sitemap(): Promise<MetadataRoute.Sitemap> {\n    try {\n      const items = await props.client.query(props.query, props.args ?? {});\n      if (!Array.isArray(items)) {\n        return [];\n      }\n      const { getUpdatedAt } = props;\n      // `Array.isArray` widens a generic return to `any[]`, so the element\n      // type is restated here rather than asserted on `items`.\n      return items.map((item: ArrayItem<FunctionReturnType<Query>>) => {\n        // Resolved per item, not per call: a collection can carry `updatedAt`\n        // while an individual seeded or imported row has never been written\n        // through the API. `new Date(undefined)` is an `Invalid Date`, which\n        // serializes to a `<lastmod>` no crawler can parse, so the tag is\n        // dropped for that entry instead.\n        const updatedAt = getUpdatedAt?.(item);\n        return {\n          url: props.toUrl(props.getSlug(item)),\n          ...(typeof updatedAt === \"number\" && Number.isFinite(updatedAt)\n            ? { lastModified: new Date(updatedAt) }\n            : {}),\n        };\n      });\n    } catch {\n      // Unreachable deployment, or any other read failure.\n      return [];\n    }\n  };\n}\n","import type { Metadata } from \"next\";\n\n/**\n * Builds a Next.js `Metadata` object with unconditional title/description, a\n * conditional OG image, `metadataBase`, and a canonical link.\n *\n * Generalizes what Step 1 fixed by hand in `apps/www/src/lib/metadata.ts`:\n * title and description are set regardless of whether an OG image resolved —\n * only the `openGraph.images` entry is conditional on `props.imageUrl`. The\n * original gated the whole `openGraph` block on the image, so a page without\n * one published no OG title or description at all.\n *\n * This FORMATS metadata; it does not read Convex. Resolving which title and\n * description win is the caller's job, because only the caller knows the\n * page/site precedence rules.\n *\n * @param props - Metadata inputs.\n * @returns A `Metadata` object for a page's `generateMetadata` or static\n *   `metadata` export.\n */\nexport function vexMetadata(props: {\n  description?: string;\n  /** Absolute OG image URL. Omit to emit `openGraph` without an image. */\n  imageUrl?: string;\n  /** The page's path (e.g. `/about`), used for the canonical link. */\n  path: string;\n  /** The site's absolute origin, used for `metadataBase`. */\n  siteUrl: string;\n  title: string;\n}): Metadata {\n  return {\n    alternates: { canonical: props.path },\n    description: props.description,\n    metadataBase: new URL(props.siteUrl),\n    // `openGraph` is ALWAYS emitted. Gating the whole block on an image is the\n    // defect Step 1 fixed in `apps/www/src/lib/metadata.ts`: a page with no\n    // uploaded image published no `og:title` and no `og:description` at all.\n    // Only `images` is conditional.\n    openGraph: {\n      description: props.description,\n      title: props.title,\n      ...(props.imageUrl === undefined || props.imageUrl === \"\"\n        ? {}\n        : { images: [{ url: props.imageUrl }] }),\n    },\n    title: props.title,\n  };\n}\n","import type { FunctionReference, FunctionReturnType, OptionalRestArgs } from \"convex/server\";\n\nimport type { VexServerClient } from \"../cache/types\";\n\ntype ArrayItem<T> = T extends (infer Item)[] ? Item : never;\n\n/**\n * Builds Next.js `generateStaticParams` output for a slug-driven route from a\n * Convex query.\n *\n * Returns `[]` when the read fails — including an unreachable Convex\n * deployment, which every CI build hits because it supplies placeholder env\n * rather than skipping validation (P-020). A route with no static params still\n * renders correctly on demand; it is simply not prerendered until the next\n * build.\n *\n * @param props - Static params configuration.\n * @returns `{ [paramName]: string }[]`, or `[]` if the read fails.\n */\nexport async function vexStaticParams<Query extends FunctionReference<\"query\">>(props: {\n  args?: OptionalRestArgs<Query>[0];\n  client: VexServerClient;\n  getSlug: (item: ArrayItem<FunctionReturnType<Query>>) => string;\n  paramName: string;\n  query: Query;\n}): Promise<Record<string, string>[]> {\n  try {\n    const items = await props.client.query(props.query, props.args ?? {});\n    if (!Array.isArray(items)) {\n      return [];\n    }\n    // `Array.isArray` widens a generic return to `any[]`, so the element type\n    // is restated here rather than asserted on `items`.\n    return items.map((item: ArrayItem<FunctionReturnType<Query>>) => ({\n      [props.paramName]: props.getSlug(item),\n    }));\n  } catch {\n    // Unreachable deployment, or any other read failure. An empty list means\n    // \"prerender nothing\", which is correct — the route still renders on\n    // demand — and never fails the build.\n    return [];\n  }\n}\n"],"mappings":";AASO,SAAS,gBAAgB,OAYD;AAC7B,SAAO,SAAS,SAA+B;AAC7C,UAAM,WAAW,MAAM,YAAY,CAAC;AACpC,WAAO;AAAA,MACL,OAAO;AAAA,QACL,OAAO;AAAA,QACP,WAAW;AAAA,QACX,GAAI,SAAS,WAAW,IAAI,CAAC,IAAI,EAAE,SAAS;AAAA,MAC9C;AAAA,MACA,SAAS,GAAG,MAAM,OAAO;AAAA,IAC3B;AAAA,EACF;AACF;;;AChBO,SAAS,iBAA2D,OAwBlC;AACvC,SAAO,eAAe,UAA0C;AAC9D,QAAI;AACF,YAAM,QAAQ,MAAM,MAAM,OAAO,MAAM,MAAM,OAAO,MAAM,QAAQ,CAAC,CAAC;AACpE,UAAI,CAAC,MAAM,QAAQ,KAAK,GAAG;AACzB,eAAO,CAAC;AAAA,MACV;AACA,YAAM,EAAE,aAAa,IAAI;AAGzB,aAAO,MAAM,IAAI,CAAC,SAA+C;AAM/D,cAAM,YAAY,eAAe,IAAI;AACrC,eAAO;AAAA,UACL,KAAK,MAAM,MAAM,MAAM,QAAQ,IAAI,CAAC;AAAA,UACpC,GAAI,OAAO,cAAc,YAAY,OAAO,SAAS,SAAS,IAC1D,EAAE,cAAc,IAAI,KAAK,SAAS,EAAE,IACpC,CAAC;AAAA,QACP;AAAA,MACF,CAAC;AAAA,IACH,QAAQ;AAEN,aAAO,CAAC;AAAA,IACV;AAAA,EACF;AACF;;;AClDO,SAAS,YAAY,OASf;AACX,SAAO;AAAA,IACL,YAAY,EAAE,WAAW,MAAM,KAAK;AAAA,IACpC,aAAa,MAAM;AAAA,IACnB,cAAc,IAAI,IAAI,MAAM,OAAO;AAAA;AAAA;AAAA;AAAA;AAAA,IAKnC,WAAW;AAAA,MACT,aAAa,MAAM;AAAA,MACnB,OAAO,MAAM;AAAA,MACb,GAAI,MAAM,aAAa,UAAa,MAAM,aAAa,KACnD,CAAC,IACD,EAAE,QAAQ,CAAC,EAAE,KAAK,MAAM,SAAS,CAAC,EAAE;AAAA,IAC1C;AAAA,IACA,OAAO,MAAM;AAAA,EACf;AACF;;;AC5BA,eAAsB,gBAA0D,OAM1C;AACpC,MAAI;AACF,UAAM,QAAQ,MAAM,MAAM,OAAO,MAAM,MAAM,OAAO,MAAM,QAAQ,CAAC,CAAC;AACpE,QAAI,CAAC,MAAM,QAAQ,KAAK,GAAG;AACzB,aAAO,CAAC;AAAA,IACV;AAGA,WAAO,MAAM,IAAI,CAAC,UAAgD;AAAA,MAChE,CAAC,MAAM,SAAS,GAAG,MAAM,QAAQ,IAAI;AAAA,IACvC,EAAE;AAAA,EACJ,QAAQ;AAIN,WAAO,CAAC;AAAA,EACV;AACF;","names":[]}

package/dist/chunk-L6N3D6L5.js

@@ -0,0 +1,155 @@
+// src/NextAdminPage.tsx
+import {
+  livePreviewLayoutCookieName,
+  livePreviewPanelCookieName,
+  readLivePreviewLayoutCookie,
+  readLivePreviewPanelCookie,
+  vexConvexApi
+} from "@vexcms/core";
+import {
+  CollectionEditView,
+  CollectionListView,
+  DashboardView,
+  GlobalEditView,
+  GlobalsListView,
+  MediaCollectionEditView,
+  MediaCollectionListView
+} from "@vexcms/react";
+import { fetchQuery } from "convex/nextjs";
+import { cookies } from "next/headers";
+import { jsx, jsxs } from "react/jsx-runtime";
+async function NextAdminPage(props) {
+  const { path = [] } = await props.params;
+  const [collectionSlug, documentId] = path;
+  const cookieStore = await cookies();
+  if (!collectionSlug) {
+    return /* @__PURE__ */ jsx(DashboardView, {});
+  }
+  if (collectionSlug === "globals") {
+    if (!documentId) {
+      return /* @__PURE__ */ jsx(GlobalsListView, {});
+    }
+    const globalConfig = props.config.globals.find((g) => g.slug === documentId);
+    if (!globalConfig) {
+      return /* @__PURE__ */ jsxs("div", { children: [
+        /* @__PURE__ */ jsxs("p", { className: "text-muted-foreground p-6", children: [
+          'Global "',
+          documentId,
+          '" not found.'
+        ] }),
+        /* @__PURE__ */ jsx("p", { children: "TODO: add not found view" })
+      ] });
+    }
+    const global = await fetchQuery(
+      vexConvexApi.globals.get,
+      { slug: globalConfig.slug },
+      props.token ? { token: props.token } : void 0
+    );
+    return /* @__PURE__ */ jsx(
+      GlobalEditView,
+      {
+        global: globalConfig.slug,
+        initialData: global,
+        initialPreviewPanelOpen: readLivePreviewPanelCookie({
+          cookieValue: cookieStore.get(livePreviewPanelCookieName({ slug: globalConfig.slug }))?.value,
+          defaultOpen: globalConfig.admin.livePreview?.defaultOpen ?? false
+        }),
+        initialPreviewPanelSize: readLivePreviewLayoutCookie({
+          cookieValue: cookieStore.get(livePreviewLayoutCookieName({ slug: globalConfig.slug }))?.value
+        })
+      }
+    );
+  }
+  const collection = props.config.collections.find((c) => c.slug === collectionSlug);
+  const mediaCollection = props.config.mediaCollections.find((mc) => mc.slug === collectionSlug);
+  if (!collection && !mediaCollection) {
+    return /* @__PURE__ */ jsxs("div", { children: [
+      /* @__PURE__ */ jsxs("p", { className: "text-muted-foreground p-6", children: [
+        'Collection "',
+        collectionSlug,
+        '" not found.'
+      ] }),
+      /* @__PURE__ */ jsx("p", { children: "TODO: add not found view" })
+    ] });
+  }
+  if (mediaCollection && documentId) {
+    const initialData2 = await fetchQuery(
+      vexConvexApi.get,
+      { id: documentId, collection: mediaCollection.slug },
+      props.token ? { token: props.token } : void 0
+    );
+    return /* @__PURE__ */ jsx(
+      MediaCollectionEditView,
+      {
+        collection: mediaCollection.slug,
+        documentId,
+        initialData: initialData2
+      }
+    );
+  }
+  if (mediaCollection) {
+    const numItems2 = Math.max(
+      mediaCollection.admin.table.serverPageSize,
+      mediaCollection.admin.table.defaultPageSize
+    );
+    const initialData2 = await fetchQuery(
+      vexConvexApi.find,
+      {
+        collection: collectionSlug,
+        paginationOpts: { numItems: numItems2, totalDocs: true, cursor: null }
+      },
+      props.token ? { token: props.token } : void 0
+    );
+    return /* @__PURE__ */ jsx(
+      MediaCollectionListView,
+      {
+        collection: mediaCollection.slug,
+        initialData: initialData2
+      }
+    );
+  }
+  if (collection && documentId) {
+    const initialData2 = await fetchQuery(
+      vexConvexApi.get,
+      { id: documentId, collection: collection.slug },
+      props.token ? { token: props.token } : void 0
+    );
+    return /* @__PURE__ */ jsx(
+      CollectionEditView,
+      {
+        collection: collection.slug,
+        documentId,
+        initialData: initialData2,
+        initialPreviewPanelOpen: readLivePreviewPanelCookie({
+          cookieValue: cookieStore.get(livePreviewPanelCookieName({ slug: collection.slug }))?.value,
+          defaultOpen: collection.admin.livePreview?.defaultOpen ?? false
+        }),
+        initialPreviewPanelSize: readLivePreviewLayoutCookie({
+          cookieValue: cookieStore.get(livePreviewLayoutCookieName({ slug: collection.slug }))?.value
+        })
+      }
+    );
+  }
+  if (!collection) {
+    throw new Error("invalid collection slug");
+  }
+  const numItems = Math.max(
+    collection.admin.table.serverPageSize,
+    collection.admin.table.defaultPageSize
+  );
+  const initialData = await fetchQuery(
+    vexConvexApi.findPaginated,
+    {
+      collection: collectionSlug,
+      depth: 1,
+      paginationOpts: { cursor: null, numItems, totalDocs: true }
+    },
+    props.token ? { token: props.token } : void 0
+  );
+  return /* @__PURE__ */ jsx(CollectionListView, { collection: collection.slug, initialData });
+}
+
+export {
+  NextAdminPage
+};
+//# sourceMappingURL=chunk-L6N3D6L5.js.map