@aura-stack/auth 0.1.0 → 0.2.0

package/dist/actions/signIn/signIn.cjs

@@ -36,54 +36,35 @@ module.exports = __toCommonJS(signIn_exports);
 var import_zod = __toESM(require("zod"), 1);
 var import_router2 = require("@aura-stack/router");
 
-// src/response.ts
-var AuraResponse = class extends Response {
-  static json(body, init) {
-    return Response.json(body, init);
-  }
-};
-
 // src/secure.ts
 var import_node_crypto = __toESM(require("crypto"), 1);
 
 // src/utils.ts
 var import_router = require("@aura-stack/router");
 
-// src/error.ts
-var AuthError = class extends Error {
-  constructor(type, message) {
-    super(message);
-    this.type = type;
-    this.name = "AuthError";
+// src/errors.ts
+var AuthInternalError = class extends Error {
+  type = "AUTH_INTERNAL_ERROR";
+  code;
+  constructor(code, message, options2) {
+    super(message, options2);
+    this.code = code;
+    this.name = new.target.name;
+    Error.captureStackTrace(this, new.target);
   }
 };
-var InvalidRedirectToError = class extends AuthError {
-  constructor(message = "The redirectTo parameter does not match the hosted origin.") {
-    super("invalid_redirect_to", message);
-    this.name = "InvalidRedirectToError";
+var AuthSecurityError = class extends Error {
+  type = "AUTH_SECURITY_ERROR";
+  code;
+  constructor(code, message, options2) {
+    super(message, options2);
+    this.code = code;
+    this.name = new.target.name;
+    Error.captureStackTrace(this, new.target);
   }
 };
-var isAuthError = (error) => {
-  return error instanceof AuthError;
-};
-var ERROR_RESPONSE = {
-  AUTHORIZATION: {
-    INVALID_REQUEST: "invalid_request",
-    UNAUTHORIZED_CLIENT: "unauthorized_client",
-    ACCESS_DENIED: "access_denied",
-    UNSUPPORTED_RESPONSE_TYPE: "unsupported_response_type",
-    INVALID_SCOPE: "invalid_scope",
-    SERVER_ERROR: "server_error",
-    TEMPORARILY_UNAVAILABLE: "temporarily_unavailable"
-  },
-  ACCESS_TOKEN: {
-    INVALID_REQUEST: "invalid_request",
-    INVALID_CLIENT: "invalid_client",
-    INVALID_GRANT: "invalid_grant",
-    UNAUTHORIZED_CLIENT: "unauthorized_client",
-    UNSUPPORTED_GRANT_TYPE: "unsupported_grant_type",
-    INVALID_SCOPE: "invalid_scope"
-  }
+var isAuthSecurityError = (error) => {
+  return error instanceof AuthSecurityError;
 };
 
 // src/utils.ts
@@ -103,9 +84,9 @@ var equals = (a, b) => {
   if (a === null || b === null || a === void 0 || b === void 0) return false;
   return a === b;
 };
-var sanitizeURL = (url2) => {
+var sanitizeURL = (url) => {
   try {
-    let decodedURL = decodeURIComponent(url2).trim();
+    let decodedURL = decodeURIComponent(url).trim();
     const protocolMatch = decodedURL.match(/^([a-zA-Z][a-zA-Z0-9+.-]*:\/\/)/);
     let protocol = "";
     let rest = decodedURL;
@@ -133,19 +114,41 @@ var sanitizeURL = (url2) => {
     }
     return sanitized;
   } catch {
-    return url2.trim();
+    return url.trim();
   }
 };
 var getNormalizedOriginPath = (path) => {
   try {
-    const url2 = new URL(path);
-    url2.hash = "";
-    url2.search = "";
-    return `${url2.origin}${url2.pathname}`;
+    const url = new URL(path);
+    url.hash = "";
+    url.search = "";
+    return `${url.origin}${url.pathname}`;
   } catch {
     return sanitizeURL(path);
   }
 };
+var formatZodError = (error) => {
+  if (!error.issues || error.issues.length === 0) {
+    return {};
+  }
+  return error.issues.reduce((previous, issue) => {
+    const key = issue.path.join(".");
+    return {
+      ...previous,
+      [key]: {
+        code: issue.code,
+        message: issue.message
+      }
+    };
+  }, {});
+};
+
+// src/assert.ts
+var isValidURL = (value) => {
+  if (value.includes("\r\n") || value.includes("\n") || value.includes("\r")) return false;
+  const regex = /^https?:\/\/(?:[a-zA-Z0-9._-]+|localhost|\[[0-9a-fA-F:]+\])(?::\d{1,5})?(?:\/[a-zA-Z0-9._~!$&'()*+,;=:@-]*)*\/?$/;
+  return regex.test(value);
+};
 
 // src/secure.ts
 var generateSecure = (length = 32) => {
@@ -160,117 +163,13 @@ var createPKCE = async (verifier) => {
   return { codeVerifier, codeChallenge, method: "S256" };
 };
 
-// src/cookie.ts
-var import_cookie = require("cookie");
-
-// src/assert.ts
-var isValidURL = (value) => {
-  if (value.includes("\r\n") || value.includes("\n") || value.includes("\r")) return false;
-  const regex = /^https?:\/\/(?:[a-zA-Z0-9._-]+|localhost|\[[0-9a-fA-F:]+\])(?::\d{1,5})?(?:\/[a-zA-Z0-9._~!$&'()*+,;=:@-]*)*\/?$/;
-  return regex.test(value);
-};
-
-// src/cookie.ts
-var import_cookie2 = require("cookie");
-var COOKIE_NAME = "aura-auth";
-var defaultCookieOptions = {
-  httpOnly: true,
-  sameSite: "lax",
-  path: "/",
-  maxAge: 60 * 60 * 24 * 15
-};
-var defaultStandardCookieConfig = {
-  secure: false,
-  httpOnly: true,
-  prefix: ""
-};
-var defaultSecureCookieConfig = {
-  secure: true,
-  prefix: "__Secure-"
-};
-var defaultHostCookieConfig = {
-  secure: true,
-  prefix: "__Host-",
-  path: "/",
-  domain: void 0
-};
-var expiredCookieOptions = {
-  ...defaultCookieOptions,
-  expires: /* @__PURE__ */ new Date(0),
-  maxAge: 0
-};
-var defineDefaultCookieOptions = (options2) => {
-  return {
-    name: options2?.name ?? COOKIE_NAME,
-    prefix: options2?.prefix ?? (options2?.secure ? "__Secure-" : ""),
-    ...defaultCookieOptions,
-    ...options2
-  };
-};
-var setCookie = (cookieName, value, options2) => {
-  const { prefix, name } = defineDefaultCookieOptions(options2);
-  const cookieNameWithPrefix = `${prefix}${name}.${cookieName}`;
-  return (0, import_cookie.serialize)(cookieNameWithPrefix, value, {
-    ...defaultCookieOptions,
-    ...options2
-  });
-};
-var secureCookieOptions = (request, cookieOptions, trustedProxyHeaders) => {
-  const name = cookieOptions.name ?? COOKIE_NAME;
-  const isSecure = trustedProxyHeaders ? request.url.startsWith("https://") || request.headers.get("X-Forwarded-Proto") === "https" || request.headers.get("Forwarded")?.includes("proto=https") : request.url.startsWith("https://");
-  if (!cookieOptions.options?.httpOnly) {
-    console.warn(
-      "[WARNING]: Cookie is configured without HttpOnly. This allows JavaScript access via document.cookie and increases XSS risk."
-    );
-  }
-  if (cookieOptions.options?.domain === "*") {
-    console.warn("[WARNING]: Cookie 'Domain' is set to '*', which is insecure. Avoid wildcard domains.");
-  }
-  if (!isSecure) {
-    const options2 = cookieOptions.options;
-    if (options2?.secure) {
-      console.warn(
-        "[WARNING]: The 'Secure' attribute will be disabled for this cookie. Serve over HTTPS to enforce Secure cookies."
-      );
-    }
-    if (options2?.sameSite == "none") {
-      console.warn("[WARNING]: SameSite=None without a secure connection can be blocked by browsers.");
-    }
-    if (process.env.NODE_ENV === "production") {
-      console.warn("[WARNING]: In production, ensure cookies are served over HTTPS to maintain security.");
-    }
-    return {
-      ...defaultCookieOptions,
-      ...cookieOptions.options,
-      sameSite: options2?.sameSite === "none" ? "lax" : options2?.sameSite ?? "lax",
-      ...defaultStandardCookieConfig,
-      name
-    };
-  }
-  return cookieOptions.strategy === "host" ? {
-    ...defaultCookieOptions,
-    ...cookieOptions.options,
-    ...defaultHostCookieConfig,
-    name
-  } : { ...defaultCookieOptions, ...cookieOptions.options, ...defaultSecureCookieConfig, name };
-};
-var oauthCookie = (options2) => {
-  return {
-    ...options2,
-    secure: options2.secure,
-    httpOnly: options2.httpOnly,
-    maxAge: 5 * 60,
-    expires: new Date(Date.now() + 5 * 60 * 1e3)
-  };
-};
-
 // src/schemas.ts
 var import_v4 = require("zod/v4");
 var OAuthProviderConfigSchema = (0, import_v4.object)({
-  authorizeURL: (0, import_v4.url)(),
-  accessToken: (0, import_v4.url)(),
+  authorizeURL: (0, import_v4.httpUrl)(),
+  accessToken: (0, import_v4.httpUrl)(),
   scope: (0, import_v4.string)().optional(),
-  userInfo: (0, import_v4.url)(),
+  userInfo: (0, import_v4.httpUrl)(),
   responseType: (0, import_v4.enum)(["code", "token", "id_token"]),
   clientId: (0, import_v4.string)(),
   clientSecret: (0, import_v4.string)()
@@ -282,8 +181,8 @@ var OAuthAuthorization = OAuthProviderConfigSchema.extend({
   codeChallengeMethod: (0, import_v4.enum)(["plain", "S256"])
 });
 var OAuthAuthorizationResponse = (0, import_v4.object)({
-  state: (0, import_v4.string)(),
-  code: (0, import_v4.string)()
+  state: (0, import_v4.string)("Missing state parameter in the OAuth authorization response."),
+  code: (0, import_v4.string)("Missing code parameter in the OAuth authorization response.")
 });
 var OAuthAuthorizationErrorResponse = (0, import_v4.object)({
   error: (0, import_v4.enum)([
@@ -327,12 +226,17 @@ var OAuthErrorResponse = (0, import_v4.object)({
   error: (0, import_v4.string)(),
   error_description: (0, import_v4.string)().optional()
 });
+var OAuthEnvSchema = (0, import_v4.object)({
+  clientId: import_v4.z.string().min(1, "OAuth Client ID is required in the environment variables."),
+  clientSecret: import_v4.z.string().min(1, "OAuth Client Secret is required in the environment variables.")
+});
 
 // src/actions/signIn/authorization.ts
 var createAuthorizationURL = (oauthConfig, redirectURI, state, codeChallenge, codeChallengeMethod) => {
   const parsed = OAuthAuthorization.safeParse({ ...oauthConfig, redirectURI, state, codeChallenge, codeChallengeMethod });
   if (!parsed.success) {
-    throw new AuthError(ERROR_RESPONSE.AUTHORIZATION.SERVER_ERROR, "Invalid OAuth configuration");
+    const msg = JSON.stringify(formatZodError(parsed.error), null, 2);
+    throw new AuthInternalError("INVALID_OAUTH_CONFIGURATION", msg);
   }
   const { authorizeURL, ...options2 } = parsed.data;
   const { userInfo, accessToken, clientSecret, ...required } = options2;
@@ -350,8 +254,8 @@ var getOriginURL = (request, trustedProxyHeaders) => {
   }
 };
 var createRedirectURI = (request, oauth, basePath, trustedProxyHeaders) => {
-  const url2 = getOriginURL(request, trustedProxyHeaders);
-  return `${url2.origin}${basePath}/callback/${oauth}`;
+  const url = getOriginURL(request, trustedProxyHeaders);
+  return `${url.origin}${basePath}/callback/${oauth}`;
 };
 var createRedirectTo = (request, redirectTo, trustedProxyHeaders) => {
   try {
@@ -365,15 +269,18 @@ var createRedirectTo = (request, redirectTo, trustedProxyHeaders) => {
       }
       const redirectToURL = new URL(sanitizeURL(getNormalizedOriginPath(redirectTo)));
       if (!isValidURL(redirectTo) || !equals(redirectToURL.origin, hostedURL.origin)) {
-        throw new InvalidRedirectToError();
+        throw new AuthSecurityError(
+          "POTENTIAL_OPEN_REDIRECT_ATTACK_DETECTED",
+          "The redirectTo parameter does not match the hosted origin."
+        );
       }
       return sanitizeURL(redirectToURL.pathname);
     }
     if (referer) {
       const refererURL = new URL(sanitizeURL(referer));
       if (!isValidURL(referer) || !equals(refererURL.origin, hostedURL.origin)) {
-        throw new AuthError(
-          ERROR_RESPONSE.AUTHORIZATION.INVALID_REQUEST,
+        throw new AuthSecurityError(
+          "POTENTIAL_OPEN_REDIRECT_ATTACK_DETECTED",
           "The referer of the request does not match the hosted origin."
         );
       }
@@ -382,16 +289,16 @@ var createRedirectTo = (request, redirectTo, trustedProxyHeaders) => {
     if (origin) {
       const originURL = new URL(sanitizeURL(getNormalizedOriginPath(origin)));
       if (!isValidURL(origin) || !equals(originURL.origin, hostedURL.origin)) {
-        throw new AuthError(ERROR_RESPONSE.AUTHORIZATION.INVALID_REQUEST, "Invalid origin (potential CSRF).");
+        throw new AuthSecurityError("POTENTIAL_OPEN_REDIRECT_ATTACK_DETECTED", "Invalid origin (potential CSRF).");
       }
       return sanitizeURL(originURL.pathname);
     }
     return "/";
   } catch (error) {
-    if (isAuthError(error)) {
+    if (isAuthSecurityError(error)) {
       throw error;
     }
-    throw new AuthError(ERROR_RESPONSE.AUTHORIZATION.INVALID_REQUEST, "Invalid origin (potential CSRF).");
+    throw new AuthSecurityError("POTENTIAL_OPEN_REDIRECT_ATTACK_DETECTED", "Invalid origin (potential CSRF).");
   }
 };
 
@@ -400,7 +307,7 @@ var signInConfig = (oauth) => {
   return (0, import_router2.createEndpointConfig)("/signIn/:oauth", {
     schemas: {
       params: import_zod.default.object({
-        oauth: import_zod.default.enum(Object.keys(oauth)),
+        oauth: import_zod.default.enum(Object.keys(oauth), "The OAuth provider is not supported or invalid."),
         redirectTo: import_zod.default.string().optional()
       })
     }
@@ -413,52 +320,23 @@ var signInAction = (oauth) => {
     async (ctx) => {
       const {
         request,
+        headers: headersBuilder,
         params: { oauth: oauth2, redirectTo },
         context: { oauth: providers, cookies, trustedProxyHeaders, basePath }
       } = ctx;
-      try {
-        const cookieOptions = secureCookieOptions(request, cookies, trustedProxyHeaders);
-        const state = generateSecure();
-        const redirectURI = createRedirectURI(request, oauth2, basePath, trustedProxyHeaders);
-        const stateCookie = setCookie("state", state, oauthCookie(cookieOptions));
-        const redirectURICookie = setCookie("redirect_uri", redirectURI, oauthCookie(cookieOptions));
-        const redirectToCookie = setCookie(
-          "redirect_to",
-          createRedirectTo(request, redirectTo, trustedProxyHeaders),
-          oauthCookie(cookieOptions)
-        );
-        const { codeVerifier, codeChallenge, method } = await createPKCE();
-        const codeVerifierCookie = setCookie("code_verifier", codeVerifier, oauthCookie(cookieOptions));
-        const authorization = createAuthorizationURL(providers[oauth2], redirectURI, state, codeChallenge, method);
-        const headers = new Headers();
-        headers.set("Location", authorization);
-        headers.append("Set-Cookie", stateCookie);
-        headers.append("Set-Cookie", redirectURICookie);
-        headers.append("Set-Cookie", redirectToCookie);
-        headers.append("Set-Cookie", codeVerifierCookie);
-        return Response.json(
-          { oauth: oauth2 },
-          {
-            status: 302,
-            headers
-          }
-        );
-      } catch (error) {
-        if (isAuthError(error)) {
-          const { type, message } = error;
-          return AuraResponse.json(
-            { error: type, error_description: message },
-            { status: import_router2.statusCode.BAD_REQUEST }
-          );
+      const state = generateSecure();
+      const redirectURI = createRedirectURI(request, oauth2, basePath, trustedProxyHeaders);
+      const redirectToValue = createRedirectTo(request, redirectTo, trustedProxyHeaders);
+      const { codeVerifier, codeChallenge, method } = await createPKCE();
+      const authorization = createAuthorizationURL(providers[oauth2], redirectURI, state, codeChallenge, method);
+      const headers = headersBuilder.setHeader("Location", authorization).setCookie(cookies.state.name, state, cookies.state.attributes).setCookie(cookies.redirect_uri.name, redirectURI, cookies.redirect_uri.attributes).setCookie(cookies.redirect_to.name, redirectToValue, cookies.redirect_to.attributes).setCookie(cookies.code_verifier.name, codeVerifier, cookies.code_verifier.attributes).toHeaders();
+      return Response.json(
+        { oauth: oauth2 },
+        {
+          status: 302,
+          headers
         }
-        return AuraResponse.json(
-          {
-            error: ERROR_RESPONSE.AUTHORIZATION.SERVER_ERROR,
-            error_description: "An unexpected error occurred"
-          },
-          { status: import_router2.statusCode.INTERNAL_SERVER_ERROR }
-        );
-      }
+      );
     },
     signInConfig(oauth)
   );

package/dist/actions/signIn/signIn.d.ts

@@ -1,10 +1,9 @@
 import * as _aura_stack_router from '@aura-stack/router';
-import { A as AuthRuntimeConfig } from '../../index-DpfbvTZ_.js';
+import { A as AuthRuntimeConfig } from '../../index-EqsoyjrF.js';
 import 'zod/v4';
-import '@aura-stack/jose/jose';
 import '../../schemas.js';
-import 'zod/v4/core';
-import 'cookie';
+import '@aura-stack/router/cookie';
+import '@aura-stack/jose/jose';
 import '../../@types/utility.js';
 
 declare const signInAction: (oauth: AuthRuntimeConfig["oauth"]) => _aura_stack_router.RouteEndpoint<"GET", "/signIn/:oauth", {}>;

package/dist/actions/signIn/signIn.js

@@ -1,14 +1,12 @@
 import {
   signInAction
-} from "../../chunk-LLR722CL.js";
-import "../../chunk-CAKJT3KS.js";
-import "../../chunk-ZV4BH47P.js";
-import "../../chunk-6SM22VVJ.js";
-import "../../chunk-GZU3RBTB.js";
-import "../../chunk-256KIVJL.js";
-import "../../chunk-FJUDBLCP.js";
-import "../../chunk-JAPMIE6S.js";
-import "../../chunk-HMRKN75I.js";
+} from "../../chunk-2RXNXMCZ.js";
+import "../../chunk-QEZL7EYN.js";
+import "../../chunk-WD7AUHQ5.js";
+import "../../chunk-N2APGLXA.js";
+import "../../chunk-CXLATHS5.js";
+import "../../chunk-EIL2FPSS.js";
+import "../../chunk-RRLIF4PQ.js";
 export {
   signInAction
 };