@cabin-id/nextjs 0.0.1

package/dist/esm/server/middleware.js

@@ -0,0 +1,166 @@
+import { NextResponse } from "next/server";
+import {
+  constants,
+  CUSTOM_SIGN_IN_URL,
+  PUBLISHABLE_KEY,
+  SECRET_KEY
+} from "../constants";
+import { createRouteMatcher } from "./routeMatcher";
+import {
+  apiEndpointUnauthorizedNextResponse,
+  assertKey,
+  redirectAdapter
+} from "./utils";
+import { isRedirect, mergeResponses, setHeader } from "../utils/response";
+import { createRedirect } from "./createRedirect";
+const DEFAULT_CONFIG_MATCHER = [
+  "/((?!.+\\.[\\w]+$|_next).*)",
+  "/",
+  "/(api|trpc)(.*)"
+];
+const DEFAULT_IGNORED_ROUTES = [`/((?!api|trpc))(_next.*|.+\\.[\\w]+$)`];
+const DEFAULT_API_ROUTES = ["/api/(.*)", "/trpc/(.*)"];
+const authMiddleware = (...args) => {
+  const [params = {}] = args;
+  const publishableKey = assertKey(
+    params.publishableKey || PUBLISHABLE_KEY,
+    () => {
+      throw new Error("Publish Key is not exist");
+    }
+  );
+  const secretKey = assertKey(params.secretKey || SECRET_KEY, () => {
+    throw new Error("Secret Key is not valid");
+  });
+  const signInUrl = params.signInUrl || CUSTOM_SIGN_IN_URL;
+  const signUpUrl = params.signUpUrl || CUSTOM_SIGN_IN_URL;
+  const options = {
+    ...params,
+    publishableKey,
+    secretKey,
+    signInUrl,
+    signUpUrl
+  };
+  const isIgnoredRoute = createRouteMatcher(
+    options.ignoredRoutes || DEFAULT_IGNORED_ROUTES
+  );
+  const isPublicRoute = createRouteMatcher(
+    withDefaultPublicRoutes(options.publicRoutes)
+  );
+  const isApiRoute = createApiRoutes(options.apiRoutes);
+  const defaultAfterAuth = createDefaultAfterAuth(
+    isPublicRoute,
+    isApiRoute,
+    options
+  );
+  return async (_req, evt) => {
+    const url = _req.nextUrl;
+    const accessToken = url.searchParams.get(constants.QueryParams.Token);
+    const userId = url.searchParams.get(constants.QueryParams.UserId);
+    if (isIgnoredRoute(_req) || isPublicRoute(_req)) {
+      return;
+    }
+    const nextRequest = _req;
+    const beforeAuthRes = await (options.beforeAuth && options.beforeAuth(nextRequest, evt));
+    if (beforeAuthRes === false) {
+      return setHeader(
+        NextResponse.next(),
+        constants.Headers.AuthReason,
+        "skip"
+      );
+    } else if (beforeAuthRes && isRedirect(beforeAuthRes)) {
+      return setHeader(
+        beforeAuthRes,
+        constants.Headers.AuthReason,
+        "before-auth-redirect"
+      );
+    }
+    const requestState = {
+      token: accessToken,
+      userId
+    };
+    const auth = {
+      ...requestState,
+      isPublicRoute: isPublicRoute(nextRequest),
+      isApiRoute: isApiRoute(nextRequest)
+    };
+    const afterAuthRes = await (options.afterAuth || defaultAfterAuth)(
+      auth,
+      nextRequest,
+      evt
+    );
+    const finalRes = mergeResponses(beforeAuthRes, afterAuthRes) || NextResponse.next();
+    if (accessToken && userId) {
+      const path = url.pathname;
+      const response = NextResponse.redirect(new URL(path || "/", _req.url));
+      response.cookies.set(constants.Cookies.Client, accessToken);
+      response.cookies.set(constants.Cookies.User, userId);
+      return response;
+    }
+    const result = (
+      // decorateRequest(_req, finalRes, requestState, secretKey) ||
+      NextResponse.next()
+    );
+    return result;
+  };
+};
+const withDefaultPublicRoutes = (publicRoutes) => {
+  if (typeof publicRoutes === "function") {
+    return publicRoutes;
+  }
+  const routes = [publicRoutes || ""].flat().filter(Boolean);
+  const signInUrl = process.env.NEXT_PUBLIC_CLERK_SIGN_IN_URL || "";
+  if (signInUrl) {
+    routes.push(matchRoutesStartingWith(signInUrl));
+  }
+  const signUpUrl = process.env.NEXT_PUBLIC_CLERK_SIGN_UP_URL || "";
+  if (signUpUrl) {
+    routes.push(matchRoutesStartingWith(signUpUrl));
+  }
+  return routes;
+};
+const matchRoutesStartingWith = (path) => {
+  path = path.replace(/\/$/, "");
+  return new RegExp(`^${path}(/.*)?$`);
+};
+const isRequestMethodIndicatingApiRoute = (req) => {
+  const requestMethod = req.method.toLowerCase();
+  return !["get", "head", "options"].includes(requestMethod);
+};
+const isRequestContentTypeJson = (req) => {
+  const requestContentType = req.headers.get(constants.Headers.ContentType);
+  return requestContentType === constants.ContentTypes.Json;
+};
+const createApiRoutes = (apiRoutes) => {
+  if (apiRoutes) {
+    return createRouteMatcher(apiRoutes);
+  }
+  const isDefaultApiRoute = createRouteMatcher(DEFAULT_API_ROUTES);
+  return (req) => isDefaultApiRoute(req) || isRequestMethodIndicatingApiRoute(req) || isRequestContentTypeJson(req);
+};
+const createDefaultAfterAuth = (isPublicRoute, isApiRoute, options) => {
+  return (auth, req) => {
+    if (!auth.userId && !isPublicRoute(req)) {
+      if (isApiRoute(req)) {
+        return apiEndpointUnauthorizedNextResponse();
+      }
+      return createRedirect({
+        redirectAdapter,
+        signInUrl: options.signInUrl,
+        signUpUrl: options.signUpUrl,
+        publishableKey: options.publishableKey,
+        // We're setting baseUrl to '' here as we want to keep the legacy behavior of
+        // the redirectToSignIn, redirectToSignUp helpers in the backend package.
+        baseUrl: ""
+      }).redirectToSignIn({ returnBackUrl: req.nextUrl.href });
+    }
+    return NextResponse.next();
+  };
+};
+export {
+  DEFAULT_API_ROUTES,
+  DEFAULT_CONFIG_MATCHER,
+  DEFAULT_IGNORED_ROUTES,
+  authMiddleware,
+  createDefaultAfterAuth
+};
+//# sourceMappingURL=middleware.js.map

package/dist/esm/server/middleware.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/server/middleware.ts"],"sourcesContent":["import { NextFetchEvent, NextMiddleware, NextResponse } from 'next/server';\nimport { NextRequest } from 'next/server';\nimport {\n  constants,\n  CUSTOM_SIGN_IN_URL,\n  PUBLISHABLE_KEY,\n  SECRET_KEY,\n} from '../constants';\nimport { createRouteMatcher, RouteMatcherParam } from './routeMatcher';\nimport {\n  apiEndpointUnauthorizedNextResponse,\n  assertKey,\n  // decorateRequest,\n  redirectAdapter,\n} from './utils';\nimport { NextMiddlewareReturn } from './type';\nimport { isRedirect, mergeResponses, setHeader } from '../utils/response';\nimport { createRedirect } from './createRedirect';\n// import { serverRedirectWithAuth } from './serverRedirectWithAuth';\n\ntype BeforeAuthHandler = (\n  req: NextRequest,\n  evt: NextFetchEvent\n) => NextMiddlewareReturn | false | Promise<false>;\n\ntype AfterAuthHandler = (\n  auth: { isPublicRoute: boolean; isApiRoute: boolean },\n  req: NextRequest,\n  evt: NextFetchEvent\n) => NextMiddlewareReturn;\n\nexport type AuthenticateRequestOptions = {\n  publishableKey?: string;\n  secretKey?: string;\n  domain?: string;\n  isSatellite?: boolean;\n  proxyUrl?: string;\n  signInUrl?: string;\n  signUpUrl?: string;\n  afterSignInUrl?: string;\n  afterSignUpUrl?: string;\n};\n\ntype AuthMiddlewareParams = AuthenticateRequestOptions & {\n  /**\n   * A function that is called before the authentication middleware is executed.\n   * If a redirect response is returned, the middleware will respect it and redirect the user.\n   * If false is returned, the auth middleware will not execute and the request will be handled as if the auth middleware was not present.\n   */\n  beforeAuth?: BeforeAuthHandler;\n  /**\n   * A function that is called after the authentication middleware is executed.\n   * This function has access to the auth object and can be used to execute logic based on the auth state.\n   */\n  afterAuth?: AfterAuthHandler;\n  /**\n   * A list of routes that should be accessible without authentication.\n   * You can use glob patterns to match multiple routes or a function to match against the request object.\n   * Path patterns and regular expressions are supported, for example: `['/foo', '/bar(.*)'] or `[/^\\/foo\\/.*$/]`\n   * The sign in and sign up URLs are included by default, unless a function is provided.\n   * For more information, see: https://clerk.com/docs\n   */\n  publicRoutes?: RouteMatcherParam;\n  /**\n   * A list of routes that should be ignored by the middleware.\n   * This list typically includes routes for static files or Next.js internals.\n   * For improved performance, these routes should be skipped using the default config.matcher instead.\n   */\n  ignoredRoutes?: IgnoredRoutesParam;\n  /**\n   * A list of routes that should be treated as API endpoints.\n   * When user is signed out, the middleware will return a 401 response for these routes, instead of redirecting the user.\n   *\n   * If omitted, the following heuristics will be used to determine an API endpoint:\n   * - The route path is ['/api/(.*)', '/trpc/(.*)'],\n   * - or the request has `Content-Type` set to `application/json`,\n   * - or the request method is not one of: `GET`, `OPTIONS` ,` HEAD`\n   *\n   * @default undefined\n   */\n  apiRoutes?: ApiRoutesParam;\n};\n\nexport interface AuthMiddleware {\n  (params?: AuthMiddlewareParams): NextMiddleware;\n}\n\n/**\n * The default ideal matcher that excludes the _next directory (internals) and all static files,\n * but it will match the root route (/) and any routes that start with /api or /trpc.\n */\nexport const DEFAULT_CONFIG_MATCHER = [\n  '/((?!.+\\\\.[\\\\w]+$|_next).*)',\n  '/',\n  '/(api|trpc)(.*)',\n];\n\n/**\n * Any routes matching this path will be ignored by the middleware.\n * This is the inverted version of DEFAULT_CONFIG_MATCHER.\n */\nexport const DEFAULT_IGNORED_ROUTES = [`/((?!api|trpc))(_next.*|.+\\\\.[\\\\w]+$)`];\n/**\n * Any routes matching this path will be treated as API endpoints by the middleware.\n */\nexport const DEFAULT_API_ROUTES = ['/api/(.*)', '/trpc/(.*)'];\n\ntype IgnoredRoutesParam =\n  | Array<RegExp | string>\n  | RegExp\n  | string\n  | ((req: NextRequest) => boolean);\n\ntype ApiRoutesParam = IgnoredRoutesParam;\n\nconst authMiddleware: AuthMiddleware = (...args: unknown[]) => {\n  const [params = {}] = args as [AuthMiddlewareParams?];\n\n  const publishableKey = assertKey(\n    params.publishableKey || PUBLISHABLE_KEY,\n    () => {\n      throw new Error('Publish Key is not exist');\n    }\n  );\n  const secretKey = assertKey(params.secretKey || SECRET_KEY, () => {\n    throw new Error('Secret Key is not valid');\n  });\n\n  const signInUrl = params.signInUrl || CUSTOM_SIGN_IN_URL;\n  const signUpUrl = params.signUpUrl || CUSTOM_SIGN_IN_URL;\n\n  const options = {\n    ...params,\n    publishableKey,\n    secretKey,\n    signInUrl,\n    signUpUrl,\n  };\n\n  const isIgnoredRoute = createRouteMatcher(\n    options.ignoredRoutes || DEFAULT_IGNORED_ROUTES\n  );\n  const isPublicRoute = createRouteMatcher(\n    withDefaultPublicRoutes(options.publicRoutes)\n  );\n  const isApiRoute = createApiRoutes(options.apiRoutes);\n  const defaultAfterAuth = createDefaultAfterAuth(\n    isPublicRoute,\n    isApiRoute,\n    options\n  );\n\n  return async (_req: NextRequest, evt: NextFetchEvent) => {\n    const url = _req.nextUrl;\n    const accessToken = url.searchParams.get(constants.QueryParams.Token);\n    const userId = url.searchParams.get(constants.QueryParams.UserId);\n\n    if (isIgnoredRoute(_req) || isPublicRoute(_req)) {\n      return;\n    }\n    const nextRequest = _req;\n\n    const beforeAuthRes = await (options.beforeAuth &&\n      options.beforeAuth(nextRequest, evt));\n\n    if (beforeAuthRes === false) {\n      return setHeader(\n        NextResponse.next(),\n        constants.Headers.AuthReason,\n        'skip'\n      );\n    } else if (beforeAuthRes && isRedirect(beforeAuthRes)) {\n      return setHeader(\n        beforeAuthRes,\n        constants.Headers.AuthReason,\n        'before-auth-redirect'\n      );\n    }\n\n    const requestState = {\n      token: accessToken,\n      userId,\n    };\n\n    const auth = {\n      ...requestState,\n      isPublicRoute: isPublicRoute(nextRequest),\n      isApiRoute: isApiRoute(nextRequest),\n    };\n\n    const afterAuthRes = await (options.afterAuth || defaultAfterAuth)(\n      auth,\n      nextRequest,\n      evt\n    );\n\n    const finalRes =\n      mergeResponses(beforeAuthRes, afterAuthRes) || NextResponse.next();\n\n    if (accessToken && userId) {\n      const path = url.pathname;\n      const response = NextResponse.redirect(new URL(path || '/', _req.url));\n      response.cookies.set(constants.Cookies.Client, accessToken);\n      response.cookies.set(constants.Cookies.User, userId);\n      return response;\n    }\n    \n    // if (isRedirect(finalRes)) {\n    //   const res = serverRedirectWithAuth(finalRes);\n    //   return res;\n    // }\n\n    const result =\n      // decorateRequest(_req, finalRes, requestState, secretKey) ||\n      NextResponse.next();\n\n    return result;\n  };\n};\n\nconst withDefaultPublicRoutes = (\n  publicRoutes: RouteMatcherParam | undefined\n) => {\n  if (typeof publicRoutes === 'function') {\n    return publicRoutes;\n  }\n\n  const routes = [publicRoutes || ''].flat().filter(Boolean);\n  // TODO: refactor it to use common config file eg SIGN_IN_URL from ./clerkClient\n  // we use process.env for now to support testing\n  const signInUrl = process.env.NEXT_PUBLIC_CLERK_SIGN_IN_URL || '';\n  if (signInUrl) {\n    routes.push(matchRoutesStartingWith(signInUrl));\n  }\n  // TODO: refactor it to use common config file eg SIGN_UP_URL from ./clerkClient\n  // we use process.env for now to support testing\n  const signUpUrl = process.env.NEXT_PUBLIC_CLERK_SIGN_UP_URL || '';\n  if (signUpUrl) {\n    routes.push(matchRoutesStartingWith(signUpUrl));\n  }\n  return routes;\n};\n\nconst matchRoutesStartingWith = (path: string) => {\n  path = path.replace(/\\/$/, '');\n  return new RegExp(`^${path}(/.*)?$`);\n};\n\nconst isRequestMethodIndicatingApiRoute = (req: NextRequest): boolean => {\n  const requestMethod = req.method.toLowerCase();\n  return !['get', 'head', 'options'].includes(requestMethod);\n};\n\nconst isRequestContentTypeJson = (req: NextRequest): boolean => {\n  const requestContentType = req.headers.get(constants.Headers.ContentType);\n  return requestContentType === constants.ContentTypes.Json;\n};\n\n// - Default behavior:\n//    If the route path is `['/api/(.*)*', '*/trpc/(.*)']`\n//    or Request has `Content-Type: application/json`\n//    or Request method is not-GET,OPTIONS,HEAD,\n//    then this is considered an API route.\n//\n// - If the user has provided a specific `apiRoutes` prop in `authMiddleware` then all the above are discarded,\n//   and only routes that match the user’s provided paths are considered API routes.\nconst createApiRoutes = (\n  apiRoutes: RouteMatcherParam | undefined\n): ((req: NextRequest) => boolean) => {\n  if (apiRoutes) {\n    return createRouteMatcher(apiRoutes);\n  }\n  const isDefaultApiRoute = createRouteMatcher(DEFAULT_API_ROUTES);\n  return (req: NextRequest) =>\n    isDefaultApiRoute(req) ||\n    isRequestMethodIndicatingApiRoute(req) ||\n    isRequestContentTypeJson(req);\n};\n\nexport const createDefaultAfterAuth = (\n  isPublicRoute: ReturnType<typeof createRouteMatcher>,\n  isApiRoute: ReturnType<typeof createApiRoutes>,\n  options: {\n    signInUrl: string;\n    signUpUrl: string;\n    publishableKey: string;\n    secretKey: string;\n  }\n) => {\n  return (auth: any, req: NextRequest) => {\n    if (!auth.userId && !isPublicRoute(req)) {\n      if (isApiRoute(req)) {\n        return apiEndpointUnauthorizedNextResponse();\n      }\n      return createRedirect({\n        redirectAdapter,\n        signInUrl: options.signInUrl,\n        signUpUrl: options.signUpUrl,\n        publishableKey: options.publishableKey,\n        // We're setting baseUrl to '' here as we want to keep the legacy behavior of\n        // the redirectToSignIn, redirectToSignUp helpers in the backend package.\n        baseUrl: '',\n      }).redirectToSignIn({ returnBackUrl: req.nextUrl.href });\n    }\n    return NextResponse.next();\n  };\n};\n\nexport { authMiddleware };\n"],"mappings":"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","names":[]}

package/dist/esm/server/routeMatcher.js

@@ -0,0 +1,18 @@
+import { paths } from "../utils";
+const createRouteMatcher = (routes) => {
+  if (typeof routes === "function") {
+    return (req) => routes(req);
+  }
+  const routePatterns = [routes || ""].flat().filter(Boolean);
+  const matchers = precomputePathRegex(routePatterns);
+  return (req) => matchers.some((matcher) => matcher.test(req.nextUrl.pathname));
+};
+const precomputePathRegex = (patterns) => {
+  return patterns.map(
+    (pattern) => pattern instanceof RegExp ? pattern : paths.toRegexp(pattern)
+  );
+};
+export {
+  createRouteMatcher
+};
+//# sourceMappingURL=routeMatcher.js.map

package/dist/esm/server/routeMatcher.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/server/routeMatcher.ts"],"sourcesContent":["import type Link from \"next/link\";\nimport type { NextRequest } from \"next/server\";\nimport type { Autocomplete } from \"../types\";\nimport { paths } from \"../utils\";\n\ntype WithPathPatternWildcard<T> = `${T & string}(.*)`;\ntype NextTypedRoute<T = Parameters<typeof Link>[\"0\"][\"href\"]> = T extends string\n  ? T\n  : never;\n\ntype RouteMatcherWithNextTypedRoutes = Autocomplete<\n  WithPathPatternWildcard<NextTypedRoute> | NextTypedRoute\n>;\n\nexport type RouteMatcherParam =\n  | Array<RegExp | RouteMatcherWithNextTypedRoutes>\n  | RegExp\n  | RouteMatcherWithNextTypedRoutes\n  | ((req: NextRequest) => boolean);\n\nexport const createRouteMatcher = (routes: RouteMatcherParam) => {\n  if (typeof routes === \"function\") {\n    return (req: NextRequest) => routes(req);\n  }\n\n  const routePatterns = [routes || \"\"].flat().filter(Boolean);\n  const matchers = precomputePathRegex(routePatterns);\n  return (req: NextRequest) =>\n    matchers.some((matcher) => matcher.test(req.nextUrl.pathname));\n};\n\nconst precomputePathRegex = (patterns: Array<string | RegExp>) => {\n  return patterns.map((pattern) =>\n    pattern instanceof RegExp ? pattern : paths.toRegexp(pattern),\n  );\n};\n"],"mappings":"AAGA,SAAS,aAAa;AAiBf,MAAM,qBAAqB,CAAC,WAA8B;AAC/D,MAAI,OAAO,WAAW,YAAY;AAChC,WAAO,CAAC,QAAqB,OAAO,GAAG;AAAA,EACzC;AAEA,QAAM,gBAAgB,CAAC,UAAU,EAAE,EAAE,KAAK,EAAE,OAAO,OAAO;AAC1D,QAAM,WAAW,oBAAoB,aAAa;AAClD,SAAO,CAAC,QACN,SAAS,KAAK,CAAC,YAAY,QAAQ,KAAK,IAAI,QAAQ,QAAQ,CAAC;AACjE;AAEA,MAAM,sBAAsB,CAAC,aAAqC;AAChE,SAAO,SAAS;AAAA,IAAI,CAAC,YACnB,mBAAmB,SAAS,UAAU,MAAM,SAAS,OAAO;AAAA,EAC9D;AACF;","names":[]}

package/dist/esm/server/serverRedirectWithAuth.js

@@ -0,0 +1,15 @@
+import { NextResponse } from "next/server";
+import { constants } from "../constants";
+const serverRedirectWithAuth = (res) => {
+  const location = res.headers.get("location");
+  const shouldAppendDevBrowser = res.headers.get(constants.Headers.CabinIdRedirectTo) === "true";
+  if (shouldAppendDevBrowser && !!location) {
+    const url = new URL(location);
+    return NextResponse.redirect(url.href, res);
+  }
+  return res;
+};
+export {
+  serverRedirectWithAuth
+};
+//# sourceMappingURL=serverRedirectWithAuth.js.map

package/dist/esm/server/serverRedirectWithAuth.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/server/serverRedirectWithAuth.ts"],"sourcesContent":["import { NextResponse } from 'next/server';\nimport { constants } from '../constants';\n\nexport const serverRedirectWithAuth = (res: Response) => {\n  const location = res.headers.get('location');\n  const shouldAppendDevBrowser =\n    res.headers.get(constants.Headers.CabinIdRedirectTo) === 'true';\n  if (shouldAppendDevBrowser && !!location) {\n    // Next.js 12.1+ allows redirects only to absolute URLs\n    const url = new URL(location);\n    return NextResponse.redirect(url.href, res);\n  }\n  return res;\n};\n"],"mappings":"AAAA,SAAS,oBAAoB;AAC7B,SAAS,iBAAiB;AAEnB,MAAM,yBAAyB,CAAC,QAAkB;AACvD,QAAM,WAAW,IAAI,QAAQ,IAAI,UAAU;AAC3C,QAAM,yBACJ,IAAI,QAAQ,IAAI,UAAU,QAAQ,iBAAiB,MAAM;AAC3D,MAAI,0BAA0B,CAAC,CAAC,UAAU;AAExC,UAAM,MAAM,IAAI,IAAI,QAAQ;AAC5B,WAAO,aAAa,SAAS,IAAI,MAAM,GAAG;AAAA,EAC5C;AACA,SAAO;AACT;","names":[]}

package/dist/esm/server/type.js

@@ -0,0 +1 @@
+//# sourceMappingURL=type.js.map

package/dist/esm/server/type.js.map

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

package/dist/esm/server/utils.js

@@ -0,0 +1,79 @@
+import { NextResponse } from "next/server";
+import { constants } from "../constants";
+function assertKey(key, onError) {
+  if (!key) {
+    onError();
+  }
+  return key;
+}
+const apiEndpointUnauthorizedNextResponse = () => {
+  return NextResponse.json(null, { status: 401, statusText: "Unauthorized" });
+};
+const redirectAdapter = (url) => {
+  return NextResponse.redirect(url, {
+    headers: { [constants.Headers.CabinIdRedirectTo]: "true" }
+  });
+};
+const OVERRIDE_HEADERS = "x-middleware-override-headers";
+const MIDDLEWARE_HEADER_PREFIX = "x-middleware-request";
+const setRequestHeadersOnNextResponse = (res, req, newHeaders) => {
+  if (!res.headers.get(OVERRIDE_HEADERS)) {
+    res.headers.set(OVERRIDE_HEADERS, [...req.headers.keys()]);
+    req.headers.forEach((val, key) => {
+      res.headers.set(`${MIDDLEWARE_HEADER_PREFIX}-${key}`, val);
+    });
+  }
+  Object.entries(newHeaders).forEach(([key, val]) => {
+    res.headers.set(
+      OVERRIDE_HEADERS,
+      `${res.headers.get(OVERRIDE_HEADERS)},${key}`
+    );
+    res.headers.set(`${MIDDLEWARE_HEADER_PREFIX}-${key}`, val);
+  });
+};
+function createTokenSignature(token, key) {
+  return `${token}${key}`;
+}
+function decorateRequest(req, res, requestState, secretKey) {
+  const { token } = requestState;
+  if (!res) {
+    res = NextResponse.next();
+  }
+  if (res.headers.get(constants.NextHeaders.NextRedirect)) {
+    return res;
+  }
+  let rewriteURL;
+  if (res.headers.get(constants.NextHeaders.NextResume) === "1") {
+    res.headers.delete(constants.NextHeaders.NextResume);
+    rewriteURL = new URL(req.url);
+  }
+  const rewriteURLHeader = res.headers.get(constants.NextHeaders.NextRewrite);
+  if (rewriteURLHeader) {
+    const reqURL = new URL(req.url);
+    rewriteURL = new URL(rewriteURLHeader);
+    if (rewriteURL.origin !== reqURL.origin) {
+      return res;
+    }
+  }
+  if (rewriteURL) {
+    setRequestHeadersOnNextResponse(res, req, {
+      [constants.Headers.AuthToken]: token || "",
+      [constants.Headers.AuthSignature]: token ? createTokenSignature(token, secretKey) : ""
+    });
+    const origin = rewriteURL == null ? void 0 : rewriteURL.origin;
+    const pathName = rewriteURL == null ? void 0 : rewriteURL.pathname;
+    res.headers.set(
+      constants.NextHeaders.NextRewrite,
+      `${origin}${pathName || ""}`
+    );
+  }
+  return res;
+}
+export {
+  apiEndpointUnauthorizedNextResponse,
+  assertKey,
+  decorateRequest,
+  redirectAdapter,
+  setRequestHeadersOnNextResponse
+};
+//# sourceMappingURL=utils.js.map

package/dist/esm/server/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/server/utils.ts"],"sourcesContent":["import { NextResponse } from 'next/server';\nimport type { NextRequest } from 'next/server';\nimport { constants } from '../constants';\n\nexport function assertKey(key: string, onError: () => never): string {\n  if (!key) {\n    onError();\n  }\n\n  return key;\n}\n\nexport const apiEndpointUnauthorizedNextResponse = () => {\n  return NextResponse.json(null, { status: 401, statusText: 'Unauthorized' });\n};\n\nexport const redirectAdapter = (url: string | URL) => {\n  return NextResponse.redirect(url, {\n    headers: { [constants.Headers.CabinIdRedirectTo]: 'true' },\n  });\n};\n\nconst OVERRIDE_HEADERS = 'x-middleware-override-headers';\nconst MIDDLEWARE_HEADER_PREFIX = 'x-middleware-request' as string;\n\nexport const setRequestHeadersOnNextResponse = (\n  res: NextResponse | Response,\n  req: Request,\n  newHeaders: Record<string, string>\n) => {\n  if (!res.headers.get(OVERRIDE_HEADERS)) {\n    // Emulate a user setting overrides by explicitly adding the required nextjs headers\n    // https://github.com/vercel/next.js/pull/41380\n    // @ts-expect-error\n    res.headers.set(OVERRIDE_HEADERS, [...req.headers.keys()]);\n    req.headers.forEach((val, key) => {\n      res.headers.set(`${MIDDLEWARE_HEADER_PREFIX}-${key}`, val);\n    });\n  }\n\n  // Now that we have normalised res to include overrides, just append the new header\n  Object.entries(newHeaders).forEach(([key, val]) => {\n    res.headers.set(\n      OVERRIDE_HEADERS,\n      `${res.headers.get(OVERRIDE_HEADERS)},${key}`\n    );\n    res.headers.set(`${MIDDLEWARE_HEADER_PREFIX}-${key}`, val);\n  });\n};\n\n/**\n * Compute a cryptographic signature from a session token and provided secret key. Used to validate that the token has not been modified when transferring between middleware and the Next.js origin.\n */\nfunction createTokenSignature(token: string, key: string): string {\n  return `${token}${key}`;\n}\n\ntype RequestState = any;\n\n// Auth result will be set as both a query param & header when applicable\nexport function decorateRequest(\n  req: NextRequest,\n  res: Response,\n  requestState: RequestState,\n  secretKey: string\n): Response {\n  const { token } = requestState;\n  // pass-through case, convert to next()\n  if (!res) {\n    res = NextResponse.next();\n  }\n\n  // redirect() case, return early\n  if (res.headers.get(constants.NextHeaders.NextRedirect)) {\n    return res;\n  }\n\n  let rewriteURL;\n\n  // next() case, convert to a rewrite\n  if (res.headers.get(constants.NextHeaders.NextResume) === '1') {\n    res.headers.delete(constants.NextHeaders.NextResume);\n    rewriteURL = new URL(req.url);\n  }\n\n  // rewrite() case, set auth result only if origin remains the same\n  const rewriteURLHeader = res.headers.get(constants.NextHeaders.NextRewrite);\n\n  if (rewriteURLHeader) {\n    const reqURL = new URL(req.url);\n    rewriteURL = new URL(rewriteURLHeader);\n\n    // if the origin has changed, return early\n    if (rewriteURL.origin !== reqURL.origin) {\n      return res;\n    }\n  }\n\n  if (rewriteURL) {\n    setRequestHeadersOnNextResponse(res, req, {\n      [constants.Headers.AuthToken]: token || '',\n      [constants.Headers.AuthSignature]: token\n        ? createTokenSignature(token, secretKey)\n        : '',\n    });\n    const origin = rewriteURL?.origin;\n    const pathName = rewriteURL?.pathname;\n\n    res.headers.set(\n      constants.NextHeaders.NextRewrite,\n      `${origin}${pathName || ''}`\n    );\n  }\n  return res;\n}\n"],"mappings":"AAAA,SAAS,oBAAoB;AAE7B,SAAS,iBAAiB;AAEnB,SAAS,UAAU,KAAa,SAA8B;AACnE,MAAI,CAAC,KAAK;AACR,YAAQ;AAAA,EACV;AAEA,SAAO;AACT;AAEO,MAAM,sCAAsC,MAAM;AACvD,SAAO,aAAa,KAAK,MAAM,EAAE,QAAQ,KAAK,YAAY,eAAe,CAAC;AAC5E;AAEO,MAAM,kBAAkB,CAAC,QAAsB;AACpD,SAAO,aAAa,SAAS,KAAK;AAAA,IAChC,SAAS,EAAE,CAAC,UAAU,QAAQ,iBAAiB,GAAG,OAAO;AAAA,EAC3D,CAAC;AACH;AAEA,MAAM,mBAAmB;AACzB,MAAM,2BAA2B;AAE1B,MAAM,kCAAkC,CAC7C,KACA,KACA,eACG;AACH,MAAI,CAAC,IAAI,QAAQ,IAAI,gBAAgB,GAAG;AAItC,QAAI,QAAQ,IAAI,kBAAkB,CAAC,GAAG,IAAI,QAAQ,KAAK,CAAC,CAAC;AACzD,QAAI,QAAQ,QAAQ,CAAC,KAAK,QAAQ;AAChC,UAAI,QAAQ,IAAI,GAAG,wBAAwB,IAAI,GAAG,IAAI,GAAG;AAAA,IAC3D,CAAC;AAAA,EACH;AAGA,SAAO,QAAQ,UAAU,EAAE,QAAQ,CAAC,CAAC,KAAK,GAAG,MAAM;AACjD,QAAI,QAAQ;AAAA,MACV;AAAA,MACA,GAAG,IAAI,QAAQ,IAAI,gBAAgB,CAAC,IAAI,GAAG;AAAA,IAC7C;AACA,QAAI,QAAQ,IAAI,GAAG,wBAAwB,IAAI,GAAG,IAAI,GAAG;AAAA,EAC3D,CAAC;AACH;AAKA,SAAS,qBAAqB,OAAe,KAAqB;AAChE,SAAO,GAAG,KAAK,GAAG,GAAG;AACvB;AAKO,SAAS,gBACd,KACA,KACA,cACA,WACU;AACV,QAAM,EAAE,MAAM,IAAI;AAElB,MAAI,CAAC,KAAK;AACR,UAAM,aAAa,KAAK;AAAA,EAC1B;AAGA,MAAI,IAAI,QAAQ,IAAI,UAAU,YAAY,YAAY,GAAG;AACvD,WAAO;AAAA,EACT;AAEA,MAAI;AAGJ,MAAI,IAAI,QAAQ,IAAI,UAAU,YAAY,UAAU,MAAM,KAAK;AAC7D,QAAI,QAAQ,OAAO,UAAU,YAAY,UAAU;AACnD,iBAAa,IAAI,IAAI,IAAI,GAAG;AAAA,EAC9B;AAGA,QAAM,mBAAmB,IAAI,QAAQ,IAAI,UAAU,YAAY,WAAW;AAE1E,MAAI,kBAAkB;AACpB,UAAM,SAAS,IAAI,IAAI,IAAI,GAAG;AAC9B,iBAAa,IAAI,IAAI,gBAAgB;AAGrC,QAAI,WAAW,WAAW,OAAO,QAAQ;AACvC,aAAO;AAAA,IACT;AAAA,EACF;AAEA,MAAI,YAAY;AACd,oCAAgC,KAAK,KAAK;AAAA,MACxC,CAAC,UAAU,QAAQ,SAAS,GAAG,SAAS;AAAA,MACxC,CAAC,UAAU,QAAQ,aAAa,GAAG,QAC/B,qBAAqB,OAAO,SAAS,IACrC;AAAA,IACN,CAAC;AACD,UAAM,SAAS,yCAAY;AAC3B,UAAM,WAAW,yCAAY;AAE7B,QAAI,QAAQ;AAAA,MACV,UAAU,YAAY;AAAA,MACtB,GAAG,MAAM,GAAG,YAAY,EAAE;AAAA,IAC5B;AAAA,EACF;AACA,SAAO;AACT;","names":[]}

package/dist/esm/styles/global.css

@@ -0,0 +1,334 @@
+*,
+::before,
+::after {
+  box-sizing: border-box;
+  border-width: 0;
+  border-style: solid;
+  border-color: #e5e7eb;
+}
+::before,
+::after {
+  --tw-content: "";
+}
+html,
+:host {
+  line-height: 1.5;
+  -webkit-text-size-adjust: 100%;
+  -moz-tab-size: 4;
+  -o-tab-size: 4;
+  tab-size: 4;
+  font-family:
+    ui-sans-serif,
+    system-ui,
+    sans-serif,
+    "Apple Color Emoji",
+    "Segoe UI Emoji",
+    "Segoe UI Symbol",
+    "Noto Color Emoji";
+  font-feature-settings: normal;
+  font-variation-settings: normal;
+  -webkit-tap-highlight-color: transparent;
+}
+body {
+  margin: 0;
+  line-height: inherit;
+}
+hr {
+  height: 0;
+  color: inherit;
+  border-top-width: 1px;
+}
+abbr:where([title]) {
+  -webkit-text-decoration: underline dotted;
+  text-decoration: underline dotted;
+}
+h1,
+h2,
+h3,
+h4,
+h5,
+h6 {
+  font-size: inherit;
+  font-weight: inherit;
+}
+a {
+  color: inherit;
+  text-decoration: inherit;
+}
+b,
+strong {
+  font-weight: bolder;
+}
+code,
+kbd,
+samp,
+pre {
+  font-family:
+    ui-monospace,
+    SFMono-Regular,
+    Menlo,
+    Monaco,
+    Consolas,
+    "Liberation Mono",
+    "Courier New",
+    monospace;
+  font-feature-settings: normal;
+  font-variation-settings: normal;
+  font-size: 1em;
+}
+small {
+  font-size: 80%;
+}
+sub,
+sup {
+  font-size: 75%;
+  line-height: 0;
+  position: relative;
+  vertical-align: baseline;
+}
+sub {
+  bottom: -0.25em;
+}
+sup {
+  top: -0.5em;
+}
+table {
+  text-indent: 0;
+  border-color: inherit;
+  border-collapse: collapse;
+}
+button,
+input,
+optgroup,
+select,
+textarea {
+  font-family: inherit;
+  font-feature-settings: inherit;
+  font-variation-settings: inherit;
+  font-size: 100%;
+  font-weight: inherit;
+  line-height: inherit;
+  letter-spacing: inherit;
+  color: inherit;
+  margin: 0;
+  padding: 0;
+}
+button,
+select {
+  text-transform: none;
+}
+button,
+input:where([type=button]),
+input:where([type=reset]),
+input:where([type=submit]) {
+  -webkit-appearance: button;
+  background-color: transparent;
+  background-image: none;
+}
+:-moz-focusring {
+  outline: auto;
+}
+:-moz-ui-invalid {
+  box-shadow: none;
+}
+progress {
+  vertical-align: baseline;
+}
+::-webkit-inner-spin-button,
+::-webkit-outer-spin-button {
+  height: auto;
+}
+[type=search] {
+  -webkit-appearance: textfield;
+  outline-offset: -2px;
+}
+::-webkit-search-decoration {
+  -webkit-appearance: none;
+}
+::-webkit-file-upload-button {
+  -webkit-appearance: button;
+  font: inherit;
+}
+summary {
+  display: list-item;
+}
+blockquote,
+dl,
+dd,
+h1,
+h2,
+h3,
+h4,
+h5,
+h6,
+hr,
+figure,
+p,
+pre {
+  margin: 0;
+}
+fieldset {
+  margin: 0;
+  padding: 0;
+}
+legend {
+  padding: 0;
+}
+ol,
+ul,
+menu {
+  list-style: none;
+  margin: 0;
+  padding: 0;
+}
+dialog {
+  padding: 0;
+}
+textarea {
+  resize: vertical;
+}
+input::-moz-placeholder,
+textarea::-moz-placeholder {
+  opacity: 1;
+  color: #9ca3af;
+}
+input::placeholder,
+textarea::placeholder {
+  opacity: 1;
+  color: #9ca3af;
+}
+button,
+[role=button] {
+  cursor: pointer;
+}
+:disabled {
+  cursor: default;
+}
+img,
+svg,
+video,
+canvas,
+audio,
+iframe,
+embed,
+object {
+  display: block;
+  vertical-align: middle;
+}
+img,
+video {
+  max-width: 100%;
+  height: auto;
+}
+[hidden] {
+  display: none;
+}
+*,
+::before,
+::after {
+  --tw-border-spacing-x: 0;
+  --tw-border-spacing-y: 0;
+  --tw-translate-x: 0;
+  --tw-translate-y: 0;
+  --tw-rotate: 0;
+  --tw-skew-x: 0;
+  --tw-skew-y: 0;
+  --tw-scale-x: 1;
+  --tw-scale-y: 1;
+  --tw-pan-x: ;
+  --tw-pan-y: ;
+  --tw-pinch-zoom: ;
+  --tw-scroll-snap-strictness: proximity;
+  --tw-gradient-from-position: ;
+  --tw-gradient-via-position: ;
+  --tw-gradient-to-position: ;
+  --tw-ordinal: ;
+  --tw-slashed-zero: ;
+  --tw-numeric-figure: ;
+  --tw-numeric-spacing: ;
+  --tw-numeric-fraction: ;
+  --tw-ring-inset: ;
+  --tw-ring-offset-width: 0px;
+  --tw-ring-offset-color: #fff;
+  --tw-ring-color: rgb(59 130 246 / 0.5);
+  --tw-ring-offset-shadow: 0 0 #0000;
+  --tw-ring-shadow: 0 0 #0000;
+  --tw-shadow: 0 0 #0000;
+  --tw-shadow-colored: 0 0 #0000;
+  --tw-blur: ;
+  --tw-brightness: ;
+  --tw-contrast: ;
+  --tw-grayscale: ;
+  --tw-hue-rotate: ;
+  --tw-invert: ;
+  --tw-saturate: ;
+  --tw-sepia: ;
+  --tw-drop-shadow: ;
+  --tw-backdrop-blur: ;
+  --tw-backdrop-brightness: ;
+  --tw-backdrop-contrast: ;
+  --tw-backdrop-grayscale: ;
+  --tw-backdrop-hue-rotate: ;
+  --tw-backdrop-invert: ;
+  --tw-backdrop-opacity: ;
+  --tw-backdrop-saturate: ;
+  --tw-backdrop-sepia: ;
+  --tw-contain-size: ;
+  --tw-contain-layout: ;
+  --tw-contain-paint: ;
+  --tw-contain-style: ;
+}
+::backdrop {
+  --tw-border-spacing-x: 0;
+  --tw-border-spacing-y: 0;
+  --tw-translate-x: 0;
+  --tw-translate-y: 0;
+  --tw-rotate: 0;
+  --tw-skew-x: 0;
+  --tw-skew-y: 0;
+  --tw-scale-x: 1;
+  --tw-scale-y: 1;
+  --tw-pan-x: ;
+  --tw-pan-y: ;
+  --tw-pinch-zoom: ;
+  --tw-scroll-snap-strictness: proximity;
+  --tw-gradient-from-position: ;
+  --tw-gradient-via-position: ;
+  --tw-gradient-to-position: ;
+  --tw-ordinal: ;
+  --tw-slashed-zero: ;
+  --tw-numeric-figure: ;
+  --tw-numeric-spacing: ;
+  --tw-numeric-fraction: ;
+  --tw-ring-inset: ;
+  --tw-ring-offset-width: 0px;
+  --tw-ring-offset-color: #fff;
+  --tw-ring-color: rgb(59 130 246 / 0.5);
+  --tw-ring-offset-shadow: 0 0 #0000;
+  --tw-ring-shadow: 0 0 #0000;
+  --tw-shadow: 0 0 #0000;
+  --tw-shadow-colored: 0 0 #0000;
+  --tw-blur: ;
+  --tw-brightness: ;
+  --tw-contrast: ;
+  --tw-grayscale: ;
+  --tw-hue-rotate: ;
+  --tw-invert: ;
+  --tw-saturate: ;
+  --tw-sepia: ;
+  --tw-drop-shadow: ;
+  --tw-backdrop-blur: ;
+  --tw-backdrop-brightness: ;
+  --tw-backdrop-contrast: ;
+  --tw-backdrop-grayscale: ;
+  --tw-backdrop-hue-rotate: ;
+  --tw-backdrop-invert: ;
+  --tw-backdrop-opacity: ;
+  --tw-backdrop-saturate: ;
+  --tw-backdrop-sepia: ;
+  --tw-contain-size: ;
+  --tw-contain-layout: ;
+  --tw-contain-paint: ;
+  --tw-contain-style: ;
+}
+/*# sourceMappingURL=global.css.map */