@ory/nextjs/dist/app/index.js

This library was generated with [Nx](https://nx.dev).

'use strict';

var clientFetch = require('@ory/client-fetch');
var navigation = require('next/navigation');
var headers = require('next/headers');
require('set-cookie-parser');
require('cookie');
require('psl');

// src/types.ts
var initOverrides = {
  cache: "no-cache"
};

// src/utils/sdk.ts
function orySdkUrl() {
  let baseUrl;
  if (process.env["NEXT_PUBLIC_ORY_SDK_URL"]) {
    baseUrl = process.env["NEXT_PUBLIC_ORY_SDK_URL"];
  }
  if (!baseUrl) {
    throw new Error(
      "You need to set environment variable `NEXT_PUBLIC_ORY_SDK_URL` to your Ory Network SDK URL."
    );
  }
  return baseUrl.replace(/\/$/, "");
}
function isProduction() {
  return ["production", "prod"].indexOf(
    process.env["VERCEL_ENV"] || process.env["NODE_ENV"] || ""
  ) > -1;
}
function guessPotentiallyProxiedOrySdkUrl(options) {
  if (isProduction()) {
    return orySdkUrl();
  }
  if (process.env["VERCEL_ENV"]) {
    if (!isProduction() && process.env["VERCEL_URL"]) {
      return `https://${process.env["VERCEL_URL"]}`.replace(/\/$/, "");
    }
    if (process.env["__NEXT_PRIVATE_ORIGIN"]) {
      return process.env["__NEXT_PRIVATE_ORIGIN"].replace(/\/$/, "");
    }
  }
  if (typeof window !== "undefined") {
    return window.location.origin;
  }
  if (options?.knownProxiedUrl) {
    return options.knownProxiedUrl;
  }
  const final = orySdkUrl();
  console.warn(
    `Unable to determine a suitable SDK URL for setting up the Next.js integration of Ory Elements. Will proceed using default Ory SDK URL "${final}". This is likely not what you want for local development and your authentication and login may not work.`
  );
  return final;
}

// src/app/client.ts
var serverSideFrontendClient = new clientFetch.FrontendApi(
  new clientFetch.Configuration({
    headers: {
      Accept: "application/json"
    },
    basePath: orySdkUrl()
  })
);

// src/utils/rewrite.ts
function rewriteJsonResponse(obj, proxyUrl) {
  return Object.fromEntries(
    Object.entries(obj).filter(([_, value]) => value !== void 0).map(([key, value]) => {
      if (Array.isArray(value)) {
        return [
          key,
          value.map((item) => {
            if (typeof item === "object" && item !== null) {
              return rewriteJsonResponse(item, proxyUrl);
            } else if (typeof item === "string" && proxyUrl) {
              return item.replaceAll(orySdkUrl(), proxyUrl);
            }
            return item;
          }).filter((item) => item !== void 0)
        ];
      } else if (typeof value === "object" && value !== null) {
        return [key, rewriteJsonResponse(value, proxyUrl)];
      } else if (typeof value === "string" && proxyUrl) {
        return [key, value.replaceAll(orySdkUrl(), proxyUrl)];
      }
      return [key, value];
    })
  );
}

// src/utils/utils.ts
function onValidationError(value) {
  return value;
}
async function toFlowParams(params, getCookieHeader2) {
  return {
    id: params["flow"]?.toString() ?? "",
    cookie: await getCookieHeader2(),
    return_to: params["return_to"]?.toString() ?? ""
  };
}

// src/app/utils.ts
async function getCookieHeader() {
  const h = await headers.headers();
  return h.get("cookie") ?? void 0;
}
var onRedirect = (url) => {
  navigation.redirect(url);
};
async function toFlowParams2(params) {
  return toFlowParams(params, getCookieHeader);
}
async function getPublicUrl() {
  const h = await headers.headers();
  const host = h.get("host");
  const protocol = h.get("x-forwarded-proto") || "http";
  return `${protocol}://${host}`;
}

// src/app/flow.ts
async function getFlow(params, fetchFlowRaw, flowType) {
  const knownProxiedUrl = await getPublicUrl();
  const url = guessPotentiallyProxiedOrySdkUrl({
    knownProxiedUrl
  });
  const onRestartFlow = () => {
    const redirectTo = new URL(
      "/self-service/" + flowType.toString() + "/browser",
      url
    );
    redirectTo.search = queryParamsToURLSearch(params).toString();
    return navigation.redirect(redirectTo.toString(), navigation.RedirectType.replace);
  };
  if (!params["flow"]) {
    onRestartFlow();
    return;
  }
  try {
    const rawResponse = await fetchFlowRaw();
    return await rawResponse.value().then((v) => rewriteJsonResponse(v, url));
  } catch (error) {
    const errorHandler = clientFetch.handleFlowError({
      onValidationError,
      onRestartFlow,
      onRedirect
    });
    await errorHandler(error);
    return null;
  }
}
function queryParamsToURLSearch(q) {
  const url = new URLSearchParams();
  for (const key in q) {
    const v = q[key];
    if (v) {
      url.set(key, v.toString());
    }
  }
  return url.toString();
}

// src/app/login.ts
async function getLoginFlow(params) {
  const p = await toFlowParams2(await params);
  return getFlow(
    await params,
    () => serverSideFrontendClient.getLoginFlowRaw(p, initOverrides),
    clientFetch.FlowType.Login
  );
}
async function getRegistrationFlow(params) {
  const p = await toFlowParams2(await params);
  return getFlow(
    await params,
    () => serverSideFrontendClient.getRegistrationFlowRaw(p, initOverrides),
    clientFetch.FlowType.Registration
  );
}
async function getRecoveryFlow(params) {
  const p = await toFlowParams2(await params);
  return getFlow(
    await params,
    () => serverSideFrontendClient.getRecoveryFlowRaw(p, initOverrides),
    clientFetch.FlowType.Recovery
  );
}
async function getVerificationFlow(params) {
  const p = await toFlowParams2(await params);
  return getFlow(
    await params,
    () => serverSideFrontendClient.getVerificationFlowRaw(p, initOverrides),
    clientFetch.FlowType.Verification
  );
}
async function getSettingsFlow(params) {
  const p = await toFlowParams2(await params);
  return getFlow(
    await params,
    () => serverSideFrontendClient.getSettingsFlowRaw(p, initOverrides),
    clientFetch.FlowType.Settings
  );
}
async function getLogoutFlow({
  returnTo
} = {}) {
  const h = await headers.headers();
  const knownProxiedUrl = await getPublicUrl();
  const url = guessPotentiallyProxiedOrySdkUrl({
    knownProxiedUrl
  });
  return serverSideFrontendClient.createBrowserLogoutFlow({
    cookie: h.get("cookie") ?? "",
    returnTo
  }).then((v) => rewriteJsonResponse(v, url));
}

// src/app/session.ts
async function getServerSession() {
  const cookie = await getCookieHeader();
  return serverSideFrontendClient.toSession({
    cookie
  }).catch(() => null);
}

exports.getLoginFlow = getLoginFlow;
exports.getLogoutFlow = getLogoutFlow;
exports.getRecoveryFlow = getRecoveryFlow;
exports.getRegistrationFlow = getRegistrationFlow;
exports.getServerSession = getServerSession;
exports.getSettingsFlow = getSettingsFlow;
exports.getVerificationFlow = getVerificationFlow;
//# sourceMappingURL=index.js.map
//# sourceMappingURL=index.js.map