clerk-solidjs/dist/chunk/3NMAAGYH.js

Clerk for SolidJS

import { getPublicEnvVariables, getEnvVariable } from './5MCYVUKZ.js';
import { errorThrower } from './ZQDJMLYE.js';
import { getRequestEvent } from 'solid-js/web';
import { stripPrivateDataFromObject, debugRequestState, AuthStatus, createClerkRequest } from '@clerk/backend/internal';
import { createClerkClient } from '@clerk/backend';
import { isTruthy, apiUrlFromPublishableKey as apiUrlFromPublishableKey$1, handleValueOrFn, isProxyUrlRelative, isHttpOrHttps, isDevelopmentFromSecretKey } from '@clerk/shared';
import { apiUrlFromPublishableKey } from '@clerk/shared/apiUrlFromPublishableKey';

var auth = () => {
  const event = getRequestEvent();
  if (!event) {
    throw new Error("auth() must be called from within a server function");
  }
  if (!event.locals.auth) {
    throw new Error("auth() returned null. Did you implement clerkMiddleware?");
  }
  return event.locals.auth;
};
var wrapWithClerkState = (data) => {
  return { __internal_clerk_state: { ...data } };
};
function getResponseClerkState(requestState, additionalStateOptions = {}) {
  const clerkInitialState = wrapWithClerkState({
    __clerk_ssr_state: requestState.toAuth(),
    __publishableKey: requestState.publishableKey,
    __proxyUrl: requestState.proxyUrl,
    __domain: requestState.domain,
    __isSatellite: requestState.isSatellite,
    __signInUrl: requestState.signInUrl,
    __signUpUrl: requestState.signUpUrl,
    __afterSignInUrl: requestState.afterSignInUrl,
    __afterSignUpUrl: requestState.afterSignUpUrl,
    __clerk_debug: debugRequestState(requestState),
    __clerkJSUrl: getEnvVariable("CLERK_JS"),
    __clerkJSVersion: getEnvVariable("CLERK_JS_VERSION"),
    __telemetryDisabled: isTruthy(getEnvVariable("CLERK_TELEMETRY_DISABLED")),
    __telemetryDebug: isTruthy(getEnvVariable("CLERK_TELEMETRY_DEBUG")),
    __signInForceRedirectUrl: additionalStateOptions.signInForceRedirectUrl || getEnvVariable("CLERK_SIGN_IN_FORCE_REDIRECT_URL") || "",
    __signUpForceRedirectUrl: additionalStateOptions.signUpForceRedirectUrl || getEnvVariable("CLERK_SIGN_UP_FORCE_REDIRECT_URL") || "",
    __signInFallbackRedirectUrl: additionalStateOptions.signInFallbackRedirectUrl || getEnvVariable("CLERK_SIGN_IN_FALLBACK_REDIRECT_URL") || "",
    __signUpFallbackRedirectUrl: additionalStateOptions.signUpFallbackRedirectUrl || getEnvVariable("CLERK_SIGN_UP_FALLBACK_REDIRECT_URL") || ""
  });
  return {
    clerkInitialState,
    headers: requestState.headers
  };
}
var patchRequest = (request) => {
  const clonedRequest = new Request(request.url, {
    headers: request.headers,
    method: request.method,
    redirect: request.redirect,
    cache: request.cache,
    signal: request.signal
  });
  if (clonedRequest.method !== "GET" && clonedRequest.body !== null && !("duplex" in clonedRequest)) {
    clonedRequest.duplex = "half";
  }
  return clonedRequest;
};

// src/start/server/authenticate-request.ts
async function authenticateRequest(request, opts) {
  const { audience, authorizedParties } = opts;
  const {
    apiUrl,
    secretKey,
    jwtKey,
    proxyUrl,
    isSatellite,
    domain,
    publishableKey
  } = opts;
  const { signInUrl, signUpUrl, afterSignInUrl, afterSignUpUrl } = opts;
  const requestState = await createClerkClient({
    apiUrl,
    secretKey,
    jwtKey,
    proxyUrl,
    isSatellite,
    domain,
    publishableKey,
    userAgent: `${"clerk-solidjs"}@${"2.0.10"}`
  }).authenticateRequest(patchRequest(request), {
    audience,
    authorizedParties,
    signInUrl,
    signUpUrl,
    afterSignInUrl,
    afterSignUpUrl
  });
  const hasLocationHeader = requestState.headers.get("location");
  if (hasLocationHeader) {
    throw new Response(null, { status: 307, headers: requestState.headers });
  }
  if (requestState.status === AuthStatus.Handshake) {
    throw errorThrower.throw("Clerk: unexpected handshake without redirect");
  }
  return requestState;
}
getPublicEnvVariables().clerkJsVersion || "";
getPublicEnvVariables().clerkJsUrl || "";
var API_VERSION = getEnvVariable("CLERK_API_VERSION") || "v1";
var SECRET_KEY = getEnvVariable("CLERK_SECRET_KEY") || "";
var PUBLISHABLE_KEY = getPublicEnvVariables().publishableKey || "";
getEnvVariable("CLERK_ENCRYPTION_KEY") || "";
var API_URL = getEnvVariable("CLERK_API_URL") || apiUrlFromPublishableKey(PUBLISHABLE_KEY);
var DOMAIN = getPublicEnvVariables().domain || "";
var PROXY_URL = getPublicEnvVariables().proxyUrl || "";
var CLERK_JWT_KEY = getEnvVariable("CLERK_JWT_KEY") || "";
var IS_SATELLITE = getPublicEnvVariables().isSatellite || false;
var SIGN_IN_URL = getPublicEnvVariables().signInUrl || "";
var SIGN_UP_URL = getPublicEnvVariables().signUpUrl || "";
var SDK_METADATA = {
  name: "clerk-solidjs",
  version: "2.0.10",
  environment: getEnvVariable("NODE_ENV")
};
var TELEMETRY_DISABLED = getPublicEnvVariables().telemetryDisabled;
var TELEMETRY_DEBUG = getPublicEnvVariables().telemetryDebug;

// src/start/server/load-options.ts
var loadOptions = (request, overrides = {}) => {
  const clerkRequest = createClerkRequest(patchRequest(request));
  const secretKey = overrides.secretKey || SECRET_KEY;
  const publishableKey = overrides.publishableKey || PUBLISHABLE_KEY;
  const jwtKey = overrides.jwtKey || CLERK_JWT_KEY;
  const apiUrl = getEnvVariable("CLERK_API_URL") || apiUrlFromPublishableKey$1(publishableKey);
  const domain = handleValueOrFn(overrides.domain, new URL(request.url)) || DOMAIN;
  const isSatellite = handleValueOrFn(overrides.isSatellite, new URL(request.url)) || IS_SATELLITE;
  const relativeOrAbsoluteProxyUrl = handleValueOrFn(
    overrides?.proxyUrl,
    clerkRequest.clerkUrl,
    PROXY_URL
  );
  const signInUrl = overrides.signInUrl || SIGN_IN_URL;
  const signUpUrl = overrides.signUpUrl || SIGN_UP_URL;
  const afterSignInUrl = overrides.afterSignInUrl || getPublicEnvVariables().afterSignInUrl;
  const afterSignUpUrl = overrides.afterSignUpUrl || getPublicEnvVariables().afterSignUpUrl;
  let proxyUrl;
  if (!!relativeOrAbsoluteProxyUrl && isProxyUrlRelative(relativeOrAbsoluteProxyUrl)) {
    proxyUrl = new URL(
      relativeOrAbsoluteProxyUrl,
      clerkRequest.clerkUrl
    ).toString();
  } else {
    proxyUrl = relativeOrAbsoluteProxyUrl;
  }
  if (!secretKey) {
    throw errorThrower.throw("Clerk: no secret key provided");
  }
  if (isSatellite && !proxyUrl && !domain) {
    throw errorThrower.throw(
      "Clerk: satellite mode requires a proxy URL or domain"
    );
  }
  if (isSatellite && !isHttpOrHttps(signInUrl) && isDevelopmentFromSecretKey(secretKey)) {
    throw errorThrower.throw(
      "Clerk: satellite mode requires a sign-in URL in production"
    );
  }
  return {
    // used to append options that are not initialized from env
    ...overrides,
    secretKey,
    publishableKey,
    jwtKey,
    apiUrl,
    domain,
    isSatellite,
    proxyUrl,
    signInUrl,
    signUpUrl,
    afterSignInUrl,
    afterSignUpUrl
  };
};

// src/start/server/middleware.ts
var clerkMiddleware = (options = {}) => {
  return async ({ request, locals }) => {
    try {
      const loadedOptions = loadOptions(request, options);
      const requestState = await authenticateRequest(request, loadedOptions);
      const state = getResponseClerkState(requestState, loadedOptions);
      locals.auth = stripPrivateDataFromObject(requestState.toAuth());
      locals.clerkInitialState = state.clerkInitialState;
    } catch (error) {
      if (error instanceof Response) {
        return error;
      }
      throw error;
    }
  };
};
var clerkClient = (options) => createClerkClient({
  secretKey: SECRET_KEY,
  publishableKey: PUBLISHABLE_KEY,
  apiUrl: API_URL,
  apiVersion: API_VERSION,
  userAgent: `${"clerk-solidjs"}@${"2.0.10"}`,
  proxyUrl: PROXY_URL,
  domain: DOMAIN,
  isSatellite: IS_SATELLITE,
  sdkMetadata: SDK_METADATA,
  telemetry: {
    disabled: TELEMETRY_DISABLED,
    debug: TELEMETRY_DEBUG
  },
  ...options
});

export { auth, clerkClient, clerkMiddleware };