@cabin-id/nextjs 0.0.1

package/dist/cjs/server/auth.js

@@ -0,0 +1,37 @@
+"use strict";
+"use server";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var auth_exports = {};
+__export(auth_exports, {
+  auth: () => auth
+});
+module.exports = __toCommonJS(auth_exports);
+var import_headers = require("next/headers");
+var import_constants = require("../constants");
+const auth = () => {
+  var _a;
+  const cookie = (0, import_headers.cookies)();
+  const userId = ((_a = cookie.get(import_constants.constants.Cookies.User)) == null ? void 0 : _a.value) || null;
+  return { userId };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  auth
+});
+//# sourceMappingURL=auth.js.map

package/dist/cjs/server/auth.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/server/auth.ts"],"sourcesContent":["'use server';\n\nimport { cookies } from 'next/headers';\nimport { constants } from '../constants';\n\nexport const auth = () => {\n  const cookie = cookies();\n  const userId = cookie.get(constants.Cookies.User)?.value || null;\n\n  return { userId };\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAEA,qBAAwB;AACxB,uBAA0B;AAEnB,MAAM,OAAO,MAAM;AAL1B;AAME,QAAM,aAAS,wBAAQ;AACvB,QAAM,WAAS,YAAO,IAAI,2BAAU,QAAQ,IAAI,MAAjC,mBAAoC,UAAS;AAE5D,SAAO,EAAE,OAAO;AAClB;","names":[]}

package/dist/cjs/server/createRedirect.js

@@ -0,0 +1,89 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var createRedirect_exports = {};
+__export(createRedirect_exports, {
+  createRedirect: () => createRedirect
+});
+module.exports = __toCommonJS(createRedirect_exports);
+var import_key = require("../utils/key");
+const buildUrl = (_baseUrl, _targetUrl, _returnBackUrl) => {
+  if (_baseUrl === "") {
+    const legacyUrl = legacyBuildUrl(
+      _targetUrl.toString(),
+      _returnBackUrl == null ? void 0 : _returnBackUrl.toString()
+    );
+    return legacyUrl;
+  }
+  const baseUrl = new URL(_baseUrl);
+  const returnBackUrl = _returnBackUrl ? new URL(_returnBackUrl, baseUrl) : void 0;
+  const res = new URL(_targetUrl, baseUrl);
+  if (returnBackUrl) {
+    res.searchParams.set("redirect_url", returnBackUrl.toString());
+  }
+  return res.toString();
+};
+const legacyBuildUrl = (targetUrl, redirectUrl) => {
+  let url;
+  if (!targetUrl.startsWith("http")) {
+    if (!redirectUrl || !redirectUrl.startsWith("http")) {
+      throw new Error(
+        "destination url or return back url should be an absolute path url!"
+      );
+    }
+    const baseURL = new URL(redirectUrl);
+    url = new URL(targetUrl, baseURL.origin);
+  } else {
+    url = new URL(targetUrl);
+  }
+  if (redirectUrl) {
+    url.searchParams.set("redirect_url", redirectUrl);
+  }
+  return url.toString();
+};
+const createRedirect = (params) => {
+  const { publishableKey, redirectAdapter, signInUrl, signUpUrl, baseUrl } = params;
+  const frontendApi = (0, import_key.parsePublishableKey)(publishableKey);
+  const accountsBaseUrl = frontendApi;
+  const redirectToSignUp = ({ returnBackUrl } = {}) => {
+    if (!signUpUrl && !accountsBaseUrl) {
+      throw new Error("Publish Key is not exist");
+    }
+    const accountsSignUpUrl = `${accountsBaseUrl}/sign-up`;
+    const redirect = redirectAdapter(
+      buildUrl(baseUrl, signUpUrl || accountsSignUpUrl, returnBackUrl)
+    );
+    return redirect;
+  };
+  const redirectToSignIn = ({ returnBackUrl } = {}) => {
+    if (!signInUrl && !accountsBaseUrl) {
+      throw new Error("Publish Key is not exist");
+    }
+    const accountsSignInUrl = `${accountsBaseUrl}/sign-in`;
+    const redirect = redirectAdapter(
+      buildUrl(baseUrl, signInUrl || accountsSignInUrl, returnBackUrl)
+    );
+    return redirect;
+  };
+  return { redirectToSignUp, redirectToSignIn };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createRedirect
+});
+//# sourceMappingURL=createRedirect.js.map

package/dist/cjs/server/createRedirect.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/server/createRedirect.ts"],"sourcesContent":["import { parsePublishableKey } from '../utils/key';\n\ntype RedirectAdapter<RedirectReturn> = (url: string) => RedirectReturn;\ntype RedirectToParams = { returnBackUrl?: string | URL | null };\nexport type RedirectFun<ReturnType> = (params?: RedirectToParams) => ReturnType;\n\nconst buildUrl = (\n  _baseUrl: string | URL,\n  _targetUrl: string | URL,\n  _returnBackUrl?: string | URL | null\n) => {\n  if (_baseUrl === '') {\n    const legacyUrl = legacyBuildUrl(\n      _targetUrl.toString(),\n      _returnBackUrl?.toString()\n    );\n    return legacyUrl;\n  }\n\n  const baseUrl = new URL(_baseUrl);\n  const returnBackUrl = _returnBackUrl\n    ? new URL(_returnBackUrl, baseUrl)\n    : undefined;\n  const res = new URL(_targetUrl, baseUrl);\n\n  if (returnBackUrl) {\n    res.searchParams.set('redirect_url', returnBackUrl.toString());\n  }\n  return res.toString();\n};\n\nconst legacyBuildUrl = (targetUrl: string, redirectUrl?: string) => {\n  let url;\n  if (!targetUrl.startsWith('http')) {\n    if (!redirectUrl || !redirectUrl.startsWith('http')) {\n      throw new Error(\n        'destination url or return back url should be an absolute path url!'\n      );\n    }\n\n    const baseURL = new URL(redirectUrl);\n    url = new URL(targetUrl, baseURL.origin);\n  } else {\n    url = new URL(targetUrl);\n  }\n\n  if (redirectUrl) {\n    url.searchParams.set('redirect_url', redirectUrl);\n  }\n\n  return url.toString();\n};\n\n/**\n * @internal\n */\ntype CreateRedirect = <ReturnType>(params: {\n  publishableKey: string;\n  redirectAdapter: RedirectAdapter<ReturnType>;\n  baseUrl: URL | string;\n  signInUrl?: URL | string;\n  signUpUrl?: URL | string;\n}) => {\n  redirectToSignIn: RedirectFun<ReturnType>;\n  redirectToSignUp: RedirectFun<ReturnType>;\n};\n\nexport const createRedirect: CreateRedirect = (params) => {\n  const { publishableKey, redirectAdapter, signInUrl, signUpUrl, baseUrl } =\n    params;\n  const frontendApi = parsePublishableKey(publishableKey);\n  const accountsBaseUrl = frontendApi;\n\n  const redirectToSignUp = ({ returnBackUrl }: RedirectToParams = {}) => {\n    if (!signUpUrl && !accountsBaseUrl) {\n      throw new Error('Publish Key is not exist');\n    }\n    const accountsSignUpUrl = `${accountsBaseUrl}/sign-up`;\n    const redirect = redirectAdapter(\n      buildUrl(baseUrl, signUpUrl || accountsSignUpUrl, returnBackUrl)\n    );\n    return redirect;\n  };\n\n  const redirectToSignIn = ({ returnBackUrl }: RedirectToParams = {}) => {\n    if (!signInUrl && !accountsBaseUrl) {\n      throw new Error('Publish Key is not exist');\n    }\n    const accountsSignInUrl = `${accountsBaseUrl}/sign-in`;\n\n    const redirect = redirectAdapter(\n      buildUrl(baseUrl, signInUrl || accountsSignInUrl, returnBackUrl)\n    );\n\n    return redirect;\n  };\n\n  return { redirectToSignUp, redirectToSignIn };\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,iBAAoC;AAMpC,MAAM,WAAW,CACf,UACA,YACA,mBACG;AACH,MAAI,aAAa,IAAI;AACnB,UAAM,YAAY;AAAA,MAChB,WAAW,SAAS;AAAA,MACpB,iDAAgB;AAAA,IAClB;AACA,WAAO;AAAA,EACT;AAEA,QAAM,UAAU,IAAI,IAAI,QAAQ;AAChC,QAAM,gBAAgB,iBAClB,IAAI,IAAI,gBAAgB,OAAO,IAC/B;AACJ,QAAM,MAAM,IAAI,IAAI,YAAY,OAAO;AAEvC,MAAI,eAAe;AACjB,QAAI,aAAa,IAAI,gBAAgB,cAAc,SAAS,CAAC;AAAA,EAC/D;AACA,SAAO,IAAI,SAAS;AACtB;AAEA,MAAM,iBAAiB,CAAC,WAAmB,gBAAyB;AAClE,MAAI;AACJ,MAAI,CAAC,UAAU,WAAW,MAAM,GAAG;AACjC,QAAI,CAAC,eAAe,CAAC,YAAY,WAAW,MAAM,GAAG;AACnD,YAAM,IAAI;AAAA,QACR;AAAA,MACF;AAAA,IACF;AAEA,UAAM,UAAU,IAAI,IAAI,WAAW;AACnC,UAAM,IAAI,IAAI,WAAW,QAAQ,MAAM;AAAA,EACzC,OAAO;AACL,UAAM,IAAI,IAAI,SAAS;AAAA,EACzB;AAEA,MAAI,aAAa;AACf,QAAI,aAAa,IAAI,gBAAgB,WAAW;AAAA,EAClD;AAEA,SAAO,IAAI,SAAS;AACtB;AAgBO,MAAM,iBAAiC,CAAC,WAAW;AACxD,QAAM,EAAE,gBAAgB,iBAAiB,WAAW,WAAW,QAAQ,IACrE;AACF,QAAM,kBAAc,gCAAoB,cAAc;AACtD,QAAM,kBAAkB;AAExB,QAAM,mBAAmB,CAAC,EAAE,cAAc,IAAsB,CAAC,MAAM;AACrE,QAAI,CAAC,aAAa,CAAC,iBAAiB;AAClC,YAAM,IAAI,MAAM,0BAA0B;AAAA,IAC5C;AACA,UAAM,oBAAoB,GAAG,eAAe;AAC5C,UAAM,WAAW;AAAA,MACf,SAAS,SAAS,aAAa,mBAAmB,aAAa;AAAA,IACjE;AACA,WAAO;AAAA,EACT;AAEA,QAAM,mBAAmB,CAAC,EAAE,cAAc,IAAsB,CAAC,MAAM;AACrE,QAAI,CAAC,aAAa,CAAC,iBAAiB;AAClC,YAAM,IAAI,MAAM,0BAA0B;AAAA,IAC5C;AACA,UAAM,oBAAoB,GAAG,eAAe;AAE5C,UAAM,WAAW;AAAA,MACf,SAAS,SAAS,aAAa,mBAAmB,aAAa;AAAA,IACjE;AAEA,WAAO;AAAA,EACT;AAEA,SAAO,EAAE,kBAAkB,iBAAiB;AAC9C;","names":[]}

package/dist/cjs/server/getCurrentUser.js

@@ -0,0 +1,43 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var getCurrentUser_exports = {};
+__export(getCurrentUser_exports, {
+  currentUser: () => currentUser
+});
+module.exports = __toCommonJS(getCurrentUser_exports);
+var import_constants = require("../constants");
+var import_auth = require("./auth");
+async function currentUser() {
+  const { userId } = (0, import_auth.auth)();
+  if (!userId)
+    return null;
+  const response = await fetch(`${import_constants.baseApiUrl}/user/${userId}`, {
+    method: "GET",
+    headers: {
+      Authorization: `Bearer ${import_constants.SECRET_KEY}`
+    }
+  });
+  const data = await response.json();
+  return data;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  currentUser
+});
+//# sourceMappingURL=getCurrentUser.js.map

package/dist/cjs/server/getCurrentUser.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/server/getCurrentUser.ts"],"sourcesContent":["import { baseApiUrl, SECRET_KEY } from '../constants';\n\nimport { auth } from './auth';\n\nexport type User = {\n  id: string;\n  avatar: string | null;\n  email: string | null;\n  phoneNumber: string;\n  firstName: string;\n  lastName: string;\n  address: string | null;\n  createdAt: string;\n  updatedAt: string;\n};\n\nexport async function currentUser(): Promise<User | null> {\n  const { userId } = auth();\n  if (!userId) return null;\n\n  const response = await fetch(`${baseApiUrl}/user/${userId}`, {\n    method: 'GET',\n    headers: {\n      Authorization: `Bearer ${SECRET_KEY}`,\n    },\n  });\n  const data: User = await response.json();\n  return data;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,uBAAuC;AAEvC,kBAAqB;AAcrB,eAAsB,cAAoC;AACxD,QAAM,EAAE,OAAO,QAAI,kBAAK;AACxB,MAAI,CAAC;AAAQ,WAAO;AAEpB,QAAM,WAAW,MAAM,MAAM,GAAG,2BAAU,SAAS,MAAM,IAAI;AAAA,IAC3D,QAAQ;AAAA,IACR,SAAS;AAAA,MACP,eAAe,UAAU,2BAAU;AAAA,IACrC;AAAA,EACF,CAAC;AACD,QAAM,OAAa,MAAM,SAAS,KAAK;AACvC,SAAO;AACT;","names":[]}

package/dist/cjs/server/middleware.js

@@ -0,0 +1,185 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var middleware_exports = {};
+__export(middleware_exports, {
+  DEFAULT_API_ROUTES: () => DEFAULT_API_ROUTES,
+  DEFAULT_CONFIG_MATCHER: () => DEFAULT_CONFIG_MATCHER,
+  DEFAULT_IGNORED_ROUTES: () => DEFAULT_IGNORED_ROUTES,
+  authMiddleware: () => authMiddleware,
+  createDefaultAfterAuth: () => createDefaultAfterAuth
+});
+module.exports = __toCommonJS(middleware_exports);
+var import_server = require("next/server");
+var import_constants = require("../constants");
+var import_routeMatcher = require("./routeMatcher");
+var import_utils = require("./utils");
+var import_response = require("../utils/response");
+var import_createRedirect = require("./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 = (0, import_utils.assertKey)(
+    params.publishableKey || import_constants.PUBLISHABLE_KEY,
+    () => {
+      throw new Error("Publish Key is not exist");
+    }
+  );
+  const secretKey = (0, import_utils.assertKey)(params.secretKey || import_constants.SECRET_KEY, () => {
+    throw new Error("Secret Key is not valid");
+  });
+  const signInUrl = params.signInUrl || import_constants.CUSTOM_SIGN_IN_URL;
+  const signUpUrl = params.signUpUrl || import_constants.CUSTOM_SIGN_IN_URL;
+  const options = {
+    ...params,
+    publishableKey,
+    secretKey,
+    signInUrl,
+    signUpUrl
+  };
+  const isIgnoredRoute = (0, import_routeMatcher.createRouteMatcher)(
+    options.ignoredRoutes || DEFAULT_IGNORED_ROUTES
+  );
+  const isPublicRoute = (0, import_routeMatcher.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(import_constants.constants.QueryParams.Token);
+    const userId = url.searchParams.get(import_constants.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 (0, import_response.setHeader)(
+        import_server.NextResponse.next(),
+        import_constants.constants.Headers.AuthReason,
+        "skip"
+      );
+    } else if (beforeAuthRes && (0, import_response.isRedirect)(beforeAuthRes)) {
+      return (0, import_response.setHeader)(
+        beforeAuthRes,
+        import_constants.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 = (0, import_response.mergeResponses)(beforeAuthRes, afterAuthRes) || import_server.NextResponse.next();
+    if (accessToken && userId) {
+      const path = url.pathname;
+      const response = import_server.NextResponse.redirect(new URL(path || "/", _req.url));
+      response.cookies.set(import_constants.constants.Cookies.Client, accessToken);
+      response.cookies.set(import_constants.constants.Cookies.User, userId);
+      return response;
+    }
+    const result = (
+      // decorateRequest(_req, finalRes, requestState, secretKey) ||
+      import_server.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(import_constants.constants.Headers.ContentType);
+  return requestContentType === import_constants.constants.ContentTypes.Json;
+};
+const createApiRoutes = (apiRoutes) => {
+  if (apiRoutes) {
+    return (0, import_routeMatcher.createRouteMatcher)(apiRoutes);
+  }
+  const isDefaultApiRoute = (0, import_routeMatcher.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 (0, import_utils.apiEndpointUnauthorizedNextResponse)();
+      }
+      return (0, import_createRedirect.createRedirect)({
+        redirectAdapter: import_utils.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 import_server.NextResponse.next();
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_API_ROUTES,
+  DEFAULT_CONFIG_MATCHER,
+  DEFAULT_IGNORED_ROUTES,
+  authMiddleware,
+  createDefaultAfterAuth
+});
+//# sourceMappingURL=middleware.js.map

package/dist/cjs/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/cjs/server/routeMatcher.js

@@ -0,0 +1,42 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var routeMatcher_exports = {};
+__export(routeMatcher_exports, {
+  createRouteMatcher: () => createRouteMatcher
+});
+module.exports = __toCommonJS(routeMatcher_exports);
+var import_utils = require("../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 : import_utils.paths.toRegexp(pattern)
+  );
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createRouteMatcher
+});
+//# sourceMappingURL=routeMatcher.js.map

package/dist/cjs/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":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAGA,mBAAsB;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,mBAAM,SAAS,OAAO;AAAA,EAC9D;AACF;","names":[]}

package/dist/cjs/server/serverRedirectWithAuth.js

@@ -0,0 +1,39 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var serverRedirectWithAuth_exports = {};
+__export(serverRedirectWithAuth_exports, {
+  serverRedirectWithAuth: () => serverRedirectWithAuth
+});
+module.exports = __toCommonJS(serverRedirectWithAuth_exports);
+var import_server = require("next/server");
+var import_constants = require("../constants");
+const serverRedirectWithAuth = (res) => {
+  const location = res.headers.get("location");
+  const shouldAppendDevBrowser = res.headers.get(import_constants.constants.Headers.CabinIdRedirectTo) === "true";
+  if (shouldAppendDevBrowser && !!location) {
+    const url = new URL(location);
+    return import_server.NextResponse.redirect(url.href, res);
+  }
+  return res;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  serverRedirectWithAuth
+});
+//# sourceMappingURL=serverRedirectWithAuth.js.map

package/dist/cjs/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;AAAA;AAAA;AAAA;AAAA;AAAA,oBAA6B;AAC7B,uBAA0B;AAEnB,MAAM,yBAAyB,CAAC,QAAkB;AACvD,QAAM,WAAW,IAAI,QAAQ,IAAI,UAAU;AAC3C,QAAM,yBACJ,IAAI,QAAQ,IAAI,2BAAU,QAAQ,iBAAiB,MAAM;AAC3D,MAAI,0BAA0B,CAAC,CAAC,UAAU;AAExC,UAAM,MAAM,IAAI,IAAI,QAAQ;AAC5B,WAAO,2BAAa,SAAS,IAAI,MAAM,GAAG;AAAA,EAC5C;AACA,SAAO;AACT;","names":[]}

package/dist/cjs/server/type.js

@@ -0,0 +1,17 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var type_exports = {};
+module.exports = __toCommonJS(type_exports);
+//# sourceMappingURL=type.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/server/type.ts"],"sourcesContent":["import { NextMiddleware } from \"next/server\";\n\nexport type NextMiddlewareRequestParam = Parameters<NextMiddleware>['0'];\nexport type NextMiddlewareEvtParam = Parameters<NextMiddleware>['1'];\nexport type NextMiddlewareReturn = ReturnType<NextMiddleware>;\n"],"mappings":";;;;;;;;;;;;;;AAAA;AAAA;","names":[]}

package/dist/cjs/server/utils.js

@@ -0,0 +1,107 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var utils_exports = {};
+__export(utils_exports, {
+  apiEndpointUnauthorizedNextResponse: () => apiEndpointUnauthorizedNextResponse,
+  assertKey: () => assertKey,
+  decorateRequest: () => decorateRequest,
+  redirectAdapter: () => redirectAdapter,
+  setRequestHeadersOnNextResponse: () => setRequestHeadersOnNextResponse
+});
+module.exports = __toCommonJS(utils_exports);
+var import_server = require("next/server");
+var import_constants = require("../constants");
+function assertKey(key, onError) {
+  if (!key) {
+    onError();
+  }
+  return key;
+}
+const apiEndpointUnauthorizedNextResponse = () => {
+  return import_server.NextResponse.json(null, { status: 401, statusText: "Unauthorized" });
+};
+const redirectAdapter = (url) => {
+  return import_server.NextResponse.redirect(url, {
+    headers: { [import_constants.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 = import_server.NextResponse.next();
+  }
+  if (res.headers.get(import_constants.constants.NextHeaders.NextRedirect)) {
+    return res;
+  }
+  let rewriteURL;
+  if (res.headers.get(import_constants.constants.NextHeaders.NextResume) === "1") {
+    res.headers.delete(import_constants.constants.NextHeaders.NextResume);
+    rewriteURL = new URL(req.url);
+  }
+  const rewriteURLHeader = res.headers.get(import_constants.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, {
+      [import_constants.constants.Headers.AuthToken]: token || "",
+      [import_constants.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(
+      import_constants.constants.NextHeaders.NextRewrite,
+      `${origin}${pathName || ""}`
+    );
+  }
+  return res;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  apiEndpointUnauthorizedNextResponse,
+  assertKey,
+  decorateRequest,
+  redirectAdapter,
+  setRequestHeadersOnNextResponse
+});
+//# sourceMappingURL=utils.js.map

package/dist/cjs/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;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,oBAA6B;AAE7B,uBAA0B;AAEnB,SAAS,UAAU,KAAa,SAA8B;AACnE,MAAI,CAAC,KAAK;AACR,YAAQ;AAAA,EACV;AAEA,SAAO;AACT;AAEO,MAAM,sCAAsC,MAAM;AACvD,SAAO,2BAAa,KAAK,MAAM,EAAE,QAAQ,KAAK,YAAY,eAAe,CAAC;AAC5E;AAEO,MAAM,kBAAkB,CAAC,QAAsB;AACpD,SAAO,2BAAa,SAAS,KAAK;AAAA,IAChC,SAAS,EAAE,CAAC,2BAAU,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,2BAAa,KAAK;AAAA,EAC1B;AAGA,MAAI,IAAI,QAAQ,IAAI,2BAAU,YAAY,YAAY,GAAG;AACvD,WAAO;AAAA,EACT;AAEA,MAAI;AAGJ,MAAI,IAAI,QAAQ,IAAI,2BAAU,YAAY,UAAU,MAAM,KAAK;AAC7D,QAAI,QAAQ,OAAO,2BAAU,YAAY,UAAU;AACnD,iBAAa,IAAI,IAAI,IAAI,GAAG;AAAA,EAC9B;AAGA,QAAM,mBAAmB,IAAI,QAAQ,IAAI,2BAAU,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,2BAAU,QAAQ,SAAS,GAAG,SAAS;AAAA,MACxC,CAAC,2BAAU,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,2BAAU,YAAY;AAAA,MACtB,GAAG,MAAM,GAAG,YAAY,EAAE;AAAA,IAC5B;AAAA,EACF;AACA,SAAO;AACT;","names":[]}