npm - @zitadel/sdk-next - Versions diffs - 0.0.0 - Mend

@zitadel/sdk-next 0.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (26) hide show

package/LICENSE ADDED Viewed

@@ -0,0 +1,21 @@
+MIT License
+Copyright (c) 2026 ZITADEL
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md ADDED Viewed

@@ -0,0 +1,152 @@
+# @zitadel/sdk-next
+Next.js middleware and helpers for Nextgen Auth.
+## Installation
+```bash
+pnpm add @zitadel/sdk-next
+```
+## Setup
+### 1. Middleware
+Create `src/proxy.ts` at the root of your Next.js app:
+```ts
+import { nextgenMiddleware } from '@zitadel/sdk-next/middleware';
+import type { NextRequest } from 'next/server';
+export function proxy(req: NextRequest) {
+  return nextgenMiddleware(req, {
+    url: process.env.ZITADEL_URL,
+    protectedRoutes: ['/admin', '/dashboard*'],
+    loginPath: '/login',
+  });
+}
+export const config = {
+  matcher: ['/__nextgen/:path*', '/admin', '/login'],
+};
+```
+The middleware runs on every matched route and does three things in one pass:
+1. **Proxies** `/__nextgen/*` requests to the auth backend
+2. **Verifies** the session JWT via JWKS using the Web Crypto API
+3. **Redirects** unauthenticated requests to `loginPath` for protected routes
+### 2. Reading auth in a Server Component
+```ts
+import { auth } from "@zitadel/sdk-next";
+export default async function Page() {
+  const session = await auth();
+  if (!session.isAuthenticated) return <p>Not signed in</p>;
+  return <p>Hello {session.session.email}</p>;
+}
+```
+### 3. Reading auth in a Client Component
+Wrap your app in `NextgenProvider` (e.g. in your root layout):
+```tsx
+import { NextgenProvider } from '@zitadel/sdk-next';
+export default async function RootLayout({ children }) {
+  const session = await auth();
+  return (
+    <html>
+      <body>
+        <NextgenProvider value={session}>{children}</NextgenProvider>
+      </body>
+    </html>
+  );
+}
+```
+Then in any client component:
+```tsx
+'use client';
+import { useAuth } from '@zitadel/sdk-next';
+export function UserBadge() {
+  const auth = useAuth();
+  return <span>{auth.isAuthenticated ? auth.session.email : 'Guest'}</span>;
+}
+```
+### 4. Login page
+The `<zitadel-login>` web component (from `@zitadel/components`) must be rendered client-side only. Split it into a server wrapper and a client widget:
+```tsx
+// app/login/page.tsx (server)
+import { auth } from '@zitadel/sdk-next';
+import { redirect } from 'next/navigation';
+import { LoginWidget } from './widget';
+export default async function LoginPage() {
+  const session = await auth();
+  if (session.isAuthenticated) redirect('/admin');
+  return <LoginWidget />;
+}
+```
+```tsx
+// app/login/widget.tsx (client)
+'use client';
+import dynamic from 'next/dynamic';
+const ZitadelLogin = dynamic(
+  async () => {
+    await import('@zitadel/components');
+    return function ZitadelLoginElement() {
+      return (
+        <zitadel-login
+          api-base="/__nextgen"
+          project-id="demo"
+          post-sign-in-url="/admin"
+        />
+      );
+    };
+  },
+  { ssr: false },
+);
+export function LoginWidget() {
+  return <ZitadelLogin />;
+}
+```
+## Middleware options
+| Option              | Type                 | Default                  | Description                                                                                                                |
+| ------------------- | -------------------- | ------------------------ | -------------------------------------------------------------------------------------------------------------------------- |
+| `url`                 | `string`             | `ZITADEL_URL` env        | Full URL of the Zitadel auth backend                                                                                       |
+| `proxyPath`         | `string`             | `"/__nextgen"`           | Path prefix proxied to the auth backend                                                                                    |
+| `protectedRoutes`   | `string[]`           | `[]`                     | Paths requiring a valid session. Trailing `*` matches sub-paths                                                            |
+| `ignoredRoutes`     | `string[]`           | `[]`                     | Paths skipped entirely — no JWT check, no tunnelling. Useful for webhooks or health checks. Trailing `*` matches sub-paths |
+| `loginPath`         | `string`             | `"/login"`               | Where to redirect unauthenticated users                                                                                    |
+| `allowedAlgorithms` | `string[]`           | `["RS256", "ES256"]`     | JWT `alg` values to accept. Tokens with any other algorithm are rejected before JWKS is fetched                            |
+| `allowedTokenTypes` | `string[]`           | `["JWT", "at+JWT"]`      | Accepted `typ` header values (case-insensitive). Set to `[]` to disable this check                                         |
+| `clockSkewMs`       | `number`             | `5000`                   | Clock skew tolerance in ms for `exp`, `nbf`, `iat`                                                                         |
+| `jwksTimeoutMs`     | `number`             | `5000`                   | Timeout in ms for JWKS endpoint requests. Token is rejected if the fetch exceeds this window                               |
+| `audience`          | `string \| string[]` | not validated            | Expected `aud` claim value(s). When omitted, audience is not checked                                                       |
+## How JWT verification works
+1. Bearer token from `Authorization` header is checked first; `__nextgen_session` cookie is the fallback
+2. The JWT header is decoded to extract `kid` and `alg`
+3. Tokens with an `alg` not in `allowedAlgorithms` (`RS256`, `ES256` by default) are rejected immediately — no JWKS fetch
+4. Tokens with a `typ` not in `allowedTokenTypes` are rejected immediately
+5. The public key is fetched from `{url}/oauth/v2/keys` (JWKS) using the Web Crypto API, with a 5 s timeout, and cached for 5 minutes per `kid`
+6. The signature is verified **before** any claim checks
+7. `iss` must be present and must equal `url` — tokens without an issuer are rejected
+8. `exp` must be present and must be in the future (with `clockSkewMs` tolerance) — tokens without an expiry are rejected
+9. `nbf` and `iat` are validated with `clockSkewMs` tolerance when present
+10. The `x-nextgen-auth-token` header is stripped from all proxied requests to prevent internal state leakage

package/dist/auth.d.ts ADDED Viewed

@@ -0,0 +1,25 @@
+import { AuthResult } from '@zitadel/sdk-core/types';
+/**
+ * Reads the auth state in a React Server Component or Next.js Route Handler.
+ *
+ * The middleware verifies the JWT and tunnels it to the RSC runtime via
+ * `x-nextgen-auth-token`. This function decodes the tunnelled token without
+ * re-verifying the signature — verification has already been done by the
+ * middleware on every request.
+ *
+ * ```ts
+ * import { auth } from "@zitadel/sdk-next";
+ *
+ * export default async function Page() {
+ *   const session = await auth();
+ *   if (!session.isAuthenticated) return <p>Not signed in</p>;
+ *   return <p>Hello {session.session.email}</p>;
+ * }
+ * ```
+ *
+ * @returns The current {@link AuthResult}.
+ */
+declare function auth(): Promise<AuthResult>;
+export { auth };

package/dist/auth.js ADDED Viewed

@@ -0,0 +1,7 @@
+import {
+  auth
+} from "./chunk-EAUJMJ45.js";
+import "./chunk-5P5THDJF.js";
+export {
+  auth
+};

package/dist/chunk-2BFQLJQE.js ADDED Viewed

@@ -0,0 +1,27 @@
+// src/context.tsx
+import { createContext, useContext } from "react";
+import { jsx } from "react/jsx-runtime";
+var defaultValue = { isAuthenticated: false, session: null };
+var NextgenAuthContext = createContext(defaultValue);
+function NextgenProvider({
+  session,
+  children
+}) {
+  let value;
+  if (!session) {
+    value = { isAuthenticated: false, session: null };
+  } else if ("isAuthenticated" in session) {
+    value = session;
+  } else {
+    value = { isAuthenticated: true, session };
+  }
+  return /* @__PURE__ */ jsx(NextgenAuthContext.Provider, { value, children });
+}
+function useAuthContext() {
+  return useContext(NextgenAuthContext);
+}
+export {
+  NextgenProvider,
+  useAuthContext
+};

package/dist/chunk-5P5THDJF.js ADDED Viewed

@@ -0,0 +1,12 @@
+// src/lib/jwt.ts
+import {
+  JWKS_TTL_MS,
+  base64UrlDecode,
+  decodeJwt,
+  verifyJwt
+} from "@zitadel/sdk-core/jwt";
+export {
+  decodeJwt,
+  verifyJwt
+};

package/dist/chunk-6F4PWJZI.js ADDED Viewed

File without changes

package/dist/chunk-EAUJMJ45.js ADDED Viewed

@@ -0,0 +1,34 @@
+import {
+  decodeJwt
+} from "./chunk-5P5THDJF.js";
+// src/auth.ts
+import { headers } from "next/headers";
+async function auth() {
+  try {
+    const headerStore = await headers();
+    const token = headerStore.get("x-nextgen-auth-token");
+    if (!token) {
+      return { isAuthenticated: false, session: null };
+    }
+    const { payload } = decodeJwt(token);
+    if (!payload.sub) {
+      return { isAuthenticated: false, session: null };
+    }
+    return {
+      isAuthenticated: true,
+      session: {
+        userId: payload.sub,
+        email: payload.email ?? null,
+        name: payload.name ?? null,
+        token
+      }
+    };
+  } catch {
+    return { isAuthenticated: false, session: null };
+  }
+}
+export {
+  auth
+};

package/dist/chunk-UTJFJPDR.js ADDED Viewed

@@ -0,0 +1,177 @@
+import {
+  verifyJwt
+} from "./chunk-5P5THDJF.js";
+// src/middleware.ts
+import {
+  HOP_BY_HOP,
+  INTERNAL_HEADERS,
+  filterResponseHeaders,
+  matchesRoutes
+} from "@zitadel/sdk-core/middleware";
+import { NextResponse } from "next/server";
+function tunnelHeaders(req, extra) {
+  const headers = new Headers(req.headers);
+  headers.delete("x-middleware-override-headers");
+  const injectedNames = [];
+  for (const [name, value] of Object.entries(extra)) {
+    headers.set(name, value);
+    headers.set(`x-middleware-request-${name}`, value);
+    injectedNames.push(name);
+  }
+  headers.set("x-middleware-override-headers", injectedNames.join(","));
+  return headers;
+}
+async function nextgenMiddleware(req, options = {}) {
+  const {
+    url = process.env.ZITADEL_URL ?? "http://localhost:8080",
+    proxyPath = "/__nextgen",
+    protectedRoutes = [],
+    ignoredRoutes = [],
+    loginPath = "/login",
+    allowedAlgorithms = ["RS256", "ES256"],
+    clockSkewMs = 5e3,
+    audience,
+    allowedTokenTypes = ["JWT", "at+JWT"],
+    jwksTimeoutMs,
+    proxyTimeoutMs = 5e3,
+    onExchangeResponse
+  } = options;
+  if (!loginPath.startsWith("/") || loginPath.startsWith("//")) {
+    throw new Error(
+      `[nextgen] loginPath must be a relative path starting with a single "/". Received: "${loginPath}". Using an absolute or protocol-relative URL would allow open-redirect attacks.`
+    );
+  }
+  const { pathname } = new URL(req.url);
+  if (matchesRoutes(pathname, ignoredRoutes)) {
+    const headers = tunnelHeaders(req, { "x-nextgen-auth-token": "" });
+    return NextResponse.next({ request: { headers } });
+  }
+  if (pathname === proxyPath || pathname.startsWith(`${proxyPath}/`)) {
+    return proxyRequest(
+      req,
+      url,
+      proxyPath,
+      proxyTimeoutMs,
+      onExchangeResponse
+    );
+  }
+  return handleAuth(req, {
+    url,
+    protectedRoutes,
+    loginPath,
+    allowedAlgorithms,
+    clockSkewMs,
+    audience,
+    allowedTokenTypes,
+    jwksTimeoutMs,
+    pathname
+  });
+}
+async function proxyRequest(req, authUrl, proxyPath, proxyTimeoutMs, onExchangeResponse) {
+  const url = new URL(req.url);
+  const suffix = url.pathname.slice(proxyPath.length);
+  const target = `${authUrl}${suffix}${url.search}`;
+  const upstreamHeaders = new Headers();
+  for (const [key, value] of req.headers.entries()) {
+    const lower = key.toLowerCase();
+    if (!HOP_BY_HOP.has(lower) && !INTERNAL_HEADERS.has(lower)) {
+      upstreamHeaders.set(key, value);
+    }
+  }
+  const directIp = req.ip ?? req.headers.get("x-real-ip");
+  if (directIp) {
+    const existingXff = upstreamHeaders.get("x-forwarded-for");
+    upstreamHeaders.set(
+      "x-forwarded-for",
+      existingXff ? `${existingXff}, ${directIp}` : directIp
+    );
+  }
+  if (!upstreamHeaders.has("x-forwarded-host")) {
+    upstreamHeaders.set("x-forwarded-host", url.host);
+  }
+  if (!upstreamHeaders.has("x-forwarded-proto")) {
+    upstreamHeaders.set("x-forwarded-proto", url.protocol.replace(":", ""));
+  }
+  const hasBody = !["GET", "HEAD"].includes(req.method);
+  const upstream = await fetch(target, {
+    method: req.method,
+    headers: upstreamHeaders,
+    body: hasBody ? req.body : void 0,
+    redirect: "manual",
+    signal: AbortSignal.timeout(proxyTimeoutMs),
+    ...hasBody ? { duplex: "half" } : {}
+  });
+  const responseHeaders = filterResponseHeaders(upstream.headers);
+  const setCookies = upstream.headers.getSetCookie?.() ?? [];
+  for (const cookie of setCookies) {
+    responseHeaders.append("set-cookie", cookie);
+  }
+  let response = new Response(upstream.body, {
+    status: upstream.status,
+    headers: responseHeaders
+  });
+  const isExchange = req.method === "POST" && suffix.startsWith("/sessions/exchange");
+  if (isExchange && onExchangeResponse) {
+    response = await onExchangeResponse(response);
+  }
+  return response;
+}
+async function handleAuth(req, opts) {
+  const {
+    url,
+    protectedRoutes,
+    loginPath,
+    allowedAlgorithms,
+    clockSkewMs,
+    audience,
+    allowedTokenTypes,
+    jwksTimeoutMs,
+    pathname
+  } = opts;
+  const authHeader = req.headers.get("authorization");
+  const bearerToken = authHeader?.startsWith("Bearer ") ? authHeader.slice(7) : null;
+  const cookieToken = req.cookies.get("__nextgen_session")?.value ?? null;
+  const token = bearerToken ?? cookieToken;
+  const payload = token ? await verifyJwt(token, {
+    issuerUrl: url,
+    allowedAlgorithms,
+    clockSkewMs,
+    audience,
+    allowedTokenTypes,
+    jwksTimeoutMs
+  }) : null;
+  if (payload && token && payload.sub) {
+    const tunnelled2 = tunnelHeaders(req, { "x-nextgen-auth-token": token });
+    return NextResponse.next({ request: { headers: tunnelled2 } });
+  }
+  const tunnelled = tunnelHeaders(req, { "x-nextgen-auth-token": "" });
+  const staleNextgenCookies = req.cookies.getAll().filter((c) => c.name.startsWith("__nextgen"));
+  if (matchesRoutes(pathname, protectedRoutes)) {
+    const loginUrl = new URL(loginPath, req.url);
+    loginUrl.searchParams.set("next", pathname);
+    const redirect = NextResponse.redirect(loginUrl, { status: 302 });
+    for (const cookie of staleNextgenCookies) {
+      redirect.cookies.delete(cookie.name);
+    }
+    return redirect;
+  }
+  const response = NextResponse.next({ request: { headers: tunnelled } });
+  for (const cookie of staleNextgenCookies) {
+    response.cookies.delete(cookie.name);
+  }
+  return response;
+}
+function createProxy(config, options = {}) {
+  const mergedOptions = {
+    ...options,
+    proxyPath: config.proxyPath,
+    url: config.url
+  };
+  return (req) => nextgenMiddleware(req, mergedOptions);
+}
+export {
+  nextgenMiddleware,
+  createProxy
+};

package/dist/chunk-XTCHTAIQ.js ADDED Viewed

@@ -0,0 +1,12 @@
+import {
+  useAuthContext
+} from "./chunk-2BFQLJQE.js";
+// src/useAuth.ts
+function useAuth() {
+  return useAuthContext();
+}
+export {
+  useAuth
+};

package/dist/client.d.ts ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ export { ZitadelLogin, ZitadelLogout } from '@zitadel/components';
2	+ export { ZitadelConfig, ZitadelProject, configureZitadel, getApi } from '@zitadel/api/config';

package/dist/client.js ADDED Viewed

@@ -0,0 +1,9 @@
+// src/client.ts
+import { ZitadelLogin, ZitadelLogout } from "@zitadel/components";
+import { configureZitadel, getApi } from "@zitadel/api/config";
+export {
+  ZitadelLogin,
+  ZitadelLogout,
+  configureZitadel,
+  getApi
+};

package/dist/context.d.ts ADDED Viewed

@@ -0,0 +1,11 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { ReactNode } from 'react';
+import { AuthResult, NextgenSession } from '@zitadel/sdk-core/types';
+declare function NextgenProvider({ session, children, }: {
+    session: AuthResult | NextgenSession | null;
+    children: ReactNode;
+}): react_jsx_runtime.JSX.Element;
+declare function useAuthContext(): AuthResult;
+export { NextgenProvider, useAuthContext };

package/dist/context.js ADDED Viewed

@@ -0,0 +1,9 @@
+"use client";
+import {
+  NextgenProvider,
+  useAuthContext
+} from "./chunk-2BFQLJQE.js";
+export {
+  NextgenProvider,
+  useAuthContext
+};

package/dist/index.d.ts ADDED Viewed

@@ -0,0 +1,9 @@
+export { AuthResult, AuthState, NextgenMiddlewareOptions, NextgenSession, UnauthState } from '@zitadel/sdk-core/types';
+export { ProxyHandler, ProxyOptions, createProxy, nextgenMiddleware } from './middleware.js';
+export { auth } from './auth.js';
+export { NextgenProvider, useAuthContext } from './context.js';
+export { useAuth } from './useAuth.js';
+import '@zitadel/api/config';
+import 'next/server';
+import 'react/jsx-runtime';
+import 'react';

package/dist/index.js ADDED Viewed

@@ -0,0 +1,24 @@
+import {
+  createProxy,
+  nextgenMiddleware
+} from "./chunk-UTJFJPDR.js";
+import {
+  auth
+} from "./chunk-EAUJMJ45.js";
+import "./chunk-5P5THDJF.js";
+import "./chunk-6F4PWJZI.js";
+import {
+  useAuth
+} from "./chunk-XTCHTAIQ.js";
+import {
+  NextgenProvider,
+  useAuthContext
+} from "./chunk-2BFQLJQE.js";
+export {
+  NextgenProvider,
+  auth,
+  createProxy,
+  nextgenMiddleware,
+  useAuth,
+  useAuthContext
+};

package/dist/middleware.d.ts ADDED Viewed

@@ -0,0 +1,80 @@
+import { ZitadelProject } from '@zitadel/api/config';
+import { NextgenMiddlewareOptions } from '@zitadel/sdk-core/types';
+import { NextRequest, NextResponse } from 'next/server';
+/**
+ * Next.js Edge middleware that handles proxying, JWT verification, and route
+ * protection in a single pass.
+ *
+ * Place this in your `middleware.ts` file:
+ *
+ * ```ts
+ * import { nextgenMiddleware } from "@zitadel/sdk-next/middleware";
+ * import type { NextRequest } from "next/server";
+ *
+ * export function middleware(req: NextRequest) {
+ *   return nextgenMiddleware(req, {
+ *     url: process.env.ZITADEL_URL,
+ *     protectedRoutes: ["/profile"],
+ *     loginPath: "/login",
+ *   });
+ * }
+ *
+ * export const config = {
+ *   matcher: ["/__nextgen/:path*", "/profile/:path*"],
+ * };
+ * ```
+ *
+ * @param req     - The incoming Next.js edge request.
+ * @param options - Middleware configuration options.
+ * @returns A `NextResponse` or `Response` to continue, redirect, or proxy.
+ */
+declare function nextgenMiddleware(req: NextRequest, options?: NextgenMiddlewareOptions): Promise<NextResponse | Response>;
+/**
+ * Options for {@link createProxy} that are separate from the shared
+ * {@link ZitadelConfig}. These configure route protection, login
+ * redirects, and JWT verification behaviour.
+ *
+ * `proxyPath` and `url` are omitted because they come from the
+ * {@link ZitadelConfig} passed as the first argument.
+ */
+type ProxyOptions = Omit<NextgenMiddlewareOptions, 'proxyPath' | 'url'>;
+/**
+ * A pre-configured middleware handler returned by {@link createProxy}.
+ */
+type ProxyHandler = (req: NextRequest) => Promise<NextResponse | Response>;
+/**
+ * Creates a pre-configured middleware handler from the SDK config
+ * returned by `configureZitadel()`. This is the derived-service
+ * derived service pattern:
+ *
+ * ```ts
+ * // src/zitadel.ts
+ * import { configureZitadel } from "@zitadel/api/config";
+ * import { createProxy } from "@zitadel/sdk-next/middleware";
+ *
+ * const zitadel = configureZitadel({
+ *   projectId: "demo",
+ *   url: process.env.ZITADEL_URL,
+ * });
+ *
+ * export const proxy = createProxy(zitadel, {
+ *   protectedRoutes: ["/admin*"],
+ *   loginPath: "/login",
+ * });
+ * ```
+ *
+ * Then in middleware.ts:
+ *
+ * ```ts
+ * import { proxy } from "./zitadel";
+ * export const middleware = proxy;
+ * ```
+ *
+ * @param config  - The SDK handle from `configureZitadel()`.
+ * @param options - Route protection and JWT options.
+ * @returns A middleware handler function.
+ */
+declare function createProxy(config: ZitadelProject, options?: ProxyOptions): ProxyHandler;
+export { type ProxyHandler, type ProxyOptions, createProxy, nextgenMiddleware };

package/dist/middleware.js ADDED Viewed

@@ -0,0 +1,9 @@
+import {
+  createProxy,
+  nextgenMiddleware
+} from "./chunk-UTJFJPDR.js";
+import "./chunk-5P5THDJF.js";
+export {
+  createProxy,
+  nextgenMiddleware
+};

package/dist/server.d.ts ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ export { auth } from './auth.js';
2	+ import '@zitadel/sdk-core/types';

package/dist/server.js ADDED Viewed

@@ -0,0 +1,7 @@
+import {
+  auth
+} from "./chunk-EAUJMJ45.js";
+import "./chunk-5P5THDJF.js";
+export {
+  auth
+};

package/dist/tsconfig.tsbuildinfo ADDED Viewed

@@ -0,0 +1 @@

+ {"fileNames":[],"fileInfos":[],"root":[],"options":{"composite":true,"declarationMap":true,"emitDeclarationOnly":true,"importHelpers":true,"module":99,"noEmitOnError":true,"noFallthroughCasesInSwitch":true,"noImplicitOverride":true,"noImplicitReturns":true,"noUncheckedIndexedAccess":true,"noUnusedLocals":true,"skipLibCheck":true,"strict":true,"target":9,"tsBuildInfoFile":"./tsconfig.tsbuildinfo"},"version":"5.9.3"}

package/dist/types.d.ts ADDED Viewed

@@ -0,0 +1,3 @@
+export { AuthResult, AuthState, NextgenMiddlewareOptions, NextgenSession, UnauthState } from '@zitadel/sdk-core/types';
+import '@zitadel/components';
+import '@zitadel/api/config';

package/dist/types.js ADDED Viewed

	@@ -0,0 +1 @@
1	+ import "./chunk-6F4PWJZI.js";

package/dist/useAuth.d.ts ADDED Viewed

@@ -0,0 +1,5 @@
+import { AuthResult } from '@zitadel/sdk-core/types';
+declare function useAuth(): AuthResult;
+export { useAuth };

package/dist/useAuth.js ADDED Viewed

@@ -0,0 +1,8 @@
+"use client";
+import {
+  useAuth
+} from "./chunk-XTCHTAIQ.js";
+import "./chunk-2BFQLJQE.js";
+export {
+  useAuth
+};

package/package.json ADDED Viewed

@@ -0,0 +1,82 @@
+{
+  "name": "@zitadel/sdk-next",
+  "version": "0.0.0",
+  "description": "Next.js helpers and mock auth UI for Zitadel",
+  "homepage": "https://github.com/zitadel/nextgen/tree/main/packages/sdk-next#readme",
+  "bugs": {
+    "url": "https://github.com/zitadel/nextgen/issues"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/zitadel/nextgen.git",
+    "directory": "packages/sdk-next"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./server": {
+      "types": "./dist/server.d.ts",
+      "import": "./dist/server.js"
+    },
+    "./client": {
+      "types": "./dist/client.d.ts",
+      "import": "./dist/client.js"
+    },
+    "./middleware": {
+      "types": "./dist/middleware.d.ts",
+      "import": "./dist/middleware.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "server-only": "^0.0.1",
+    "@zitadel/api": "0.0.0",
+    "@zitadel/sdk-core": "0.0.0",
+    "@zitadel/components": "0.0.0"
+  },
+  "peerDependencies": {
+    "next": ">=14",
+    "react": ">=18",
+    "react-dom": ">=18"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.0.0",
+    "tsup": "^8.3.5",
+    "typescript": "^5.7.3",
+    "@eslint/json": "^0.11.0",
+    "@eslint/markdown": "^6.0.0",
+    "@testing-library/react": "^16.0.0",
+    "@testing-library/user-event": "^14.0.0",
+    "@types/react": "^19.2.14",
+    "eslint": "^9.0.0",
+    "eslint-config-prettier": "^10.0.0",
+    "eslint-import-resolver-typescript": "^3.7.0",
+    "eslint-plugin-import": "^2.31.0",
+    "eslint-plugin-jsx-a11y": "^6.10.0",
+    "eslint-plugin-perfectionist": "^4.0.0",
+    "eslint-plugin-prettier": "^5.0.0",
+    "eslint-plugin-react": "^7.37.0",
+    "eslint-plugin-react-hooks": "^5.0.0",
+    "eslint-plugin-testing-library": "^7.0.0",
+    "jsdom": "^26.0.0",
+    "next": "^16.2.4",
+    "prettier": "^3.0.0",
+    "typescript-eslint": "^8.0.0",
+    "vitest": "^3.0.0"
+  },
+  "scripts": {
+    "build": "tsup src/middleware.ts src/auth.ts src/context.tsx src/useAuth.ts src/types.ts src/index.ts src/server.ts src/client.ts --format esm --dts --clean --tsconfig tsconfig.build.json",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run --passWithNoTests",
+    "lint": "eslint ."
+  }
+}