@auth/qwik 0.1.0 → 0.2.1

package/README.md

@@ -1,16 +1,16 @@
 <p align="center">
   <a href="https://qwik.dev" target="_blank"><img height="96px" src="https://authjs.dev/img/etc/qwik.svg" /></a>
   <a href="https://qwik.authjs.dev" target="_blank"><img height="96px" src="https://authjs.dev/img/logo-sm.png" /></a>
-  <h1 align="center">Qwik Auth.js</h1>
+  <h1 align="center">Qwik Auth</h1>
 </p>
 <p align="center">
   Authentication for Qwik.
 </p>
 <p align="center">
-  <a href="https://npm.im/@auth/qwik"><img src="https://img.shields.io/badge/TypeScript-grey?style=flat-square&logo=typescript&labelColor=fff" alt="TypeScript" /></a>
-  <a href="https://www.npmtrends.com/@auth/qwik"><img src="https://img.shields.io/npm/dm/@auth/qwik?style=flat-square&color=cyan" alt="Downloads" /></a>
   <a href="https://www.npmjs.com/package/@auth/qwik"><img src="https://img.shields.io/npm/v/@auth/qwik?style=flat-square&label=latest&color=purple" alt="npm latest release" /></a>
-  <a href="https://github.com/nextauthjs/cli/stargazers"><img src="https://img.shields.io/github/stars/nextauthjs/next-auth?style=flat-square&color=orange" alt="Github Stars" /></a>
+  <a href="https://www.npmtrends.com/@auth/qwik"><img src="https://img.shields.io/npm/dm/@auth/qwik?style=flat-square&color=cyan" alt="Downloads" /></a>
+  <a href="https://github.com/nextauthjs/next-auth/stargazers"><img src="https://img.shields.io/github/stars/nextauthjs/next-auth?style=flat-square&color=orange" alt="Github Stars" /></a>
+  <img src="https://shields.io/badge/TypeScript-3178C6?logo=TypeScript&logoColor=fff&style=flat-square" alt="TypeScript" />
 </p>
 
 ---

package/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6GG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AAE5C,OAAO,EAAc,OAAO,EAAE,MAAM,kBAAkB,CAAA;AAEtD,OAAO,EAGL,CAAC,EAED,KAAK,kBAAkB,EACxB,MAAM,uBAAuB,CAAA;AAC9B,OAAO,EAAE,SAAS,EAAE,MAAM,kDAAkD,CAAA;AAI5E,8CAA8C;AAC9C,MAAM,WAAW,cAAe,SAAQ,IAAI,CAAC,UAAU,EAAE,KAAK,CAAC;CAAG;AAElE,MAAM,MAAM,gBAAgB,GAAG,OAAO,CAAC;IAAE,IAAI,EAAE,OAAO,GAAG,IAAI,CAAC;IAAC,MAAM,EAAE,GAAG,CAAA;CAAE,CAAC,CAAA;AA2G7E;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,SAAS,eArHE,kBAAkB,KAAK,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAuE7B,kBAAkB;CA8CmB,CAAA;AAmFrE,eAAO,MAAM,cAAc,QAAS,SAAS,UAAU,UAAU,SAwChE,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6GG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AAE5C,OAAO,EAAc,OAAO,EAAE,MAAM,kBAAkB,CAAA;AAEtD,OAAO,EAGL,CAAC,EAED,KAAK,kBAAkB,EACxB,MAAM,uBAAuB,CAAA;AAC9B,OAAO,EAAE,SAAS,EAAE,MAAM,kDAAkD,CAAA;AAI5E,8CAA8C;AAC9C,MAAM,WAAW,cAAe,SAAQ,IAAI,CAAC,UAAU,EAAE,KAAK,CAAC;CAAG;AAElE,MAAM,MAAM,gBAAgB,GAAG,OAAO,CAAC;IAAE,IAAI,EAAE,OAAO,GAAG,IAAI,CAAC;IAAC,MAAM,EAAE,GAAG,CAAA;CAAE,CAAC,CAAA;AA4G7E;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,SAAS,eArHE,kBAAkB,KAAK,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAuE7B,kBAAkB;CA8CmB,CAAA;AAmFrE,eAAO,MAAM,cAAc,QAAS,SAAS,UAAU,UAAU,SAwChE,CAAA"}

package/index.qwik.js

@@ -0,0 +1,353 @@
+import { globalActionQrl, zodQrl, z, routeLoaderQrl } from "@builder.io/qwik-city";
+import { inlinedQrl, useLexicalScope, implicit$FirstArg } from "@builder.io/qwik";
+import { Auth, skipCSRFCheck, isAuthAction } from "@auth/core";
+import { isServer } from "@builder.io/qwik/build";
+var setCookie = { exports: {} };
+var defaultParseOptions = {
+  decodeValues: true,
+  map: false,
+  silent: false
+};
+function isNonEmptyString(str) {
+  return typeof str === "string" && !!str.trim();
+}
+function parseString(setCookieValue, options) {
+  var parts = setCookieValue.split(";").filter(isNonEmptyString);
+  var nameValuePairStr = parts.shift();
+  var parsed = parseNameValuePair(nameValuePairStr);
+  var name = parsed.name;
+  var value = parsed.value;
+  options = options ? Object.assign({}, defaultParseOptions, options) : defaultParseOptions;
+  try {
+    value = options.decodeValues ? decodeURIComponent(value) : value;
+  } catch (e) {
+    console.error(
+      "set-cookie-parser encountered an error while decoding a cookie with value '" + value + "'. Set options.decodeValues to false to disable this feature.",
+      e
+    );
+  }
+  var cookie = {
+    name,
+    value
+  };
+  parts.forEach(function(part) {
+    var sides = part.split("=");
+    var key = sides.shift().trimLeft().toLowerCase();
+    var value2 = sides.join("=");
+    if (key === "expires") {
+      cookie.expires = new Date(value2);
+    } else if (key === "max-age") {
+      cookie.maxAge = parseInt(value2, 10);
+    } else if (key === "secure") {
+      cookie.secure = true;
+    } else if (key === "httponly") {
+      cookie.httpOnly = true;
+    } else if (key === "samesite") {
+      cookie.sameSite = value2;
+    } else {
+      cookie[key] = value2;
+    }
+  });
+  return cookie;
+}
+function parseNameValuePair(nameValuePairStr) {
+  var name = "";
+  var value = "";
+  var nameValueArr = nameValuePairStr.split("=");
+  if (nameValueArr.length > 1) {
+    name = nameValueArr.shift();
+    value = nameValueArr.join("=");
+  } else {
+    value = nameValuePairStr;
+  }
+  return { name, value };
+}
+function parse(input, options) {
+  options = options ? Object.assign({}, defaultParseOptions, options) : defaultParseOptions;
+  if (!input) {
+    if (!options.map) {
+      return [];
+    } else {
+      return {};
+    }
+  }
+  if (input.headers) {
+    if (typeof input.headers.getSetCookie === "function") {
+      input = input.headers.getSetCookie();
+    } else if (input.headers["set-cookie"]) {
+      input = input.headers["set-cookie"];
+    } else {
+      var sch = input.headers[Object.keys(input.headers).find(function(key) {
+        return key.toLowerCase() === "set-cookie";
+      })];
+      if (!sch && input.headers.cookie && !options.silent) {
+        console.warn(
+          "Warning: set-cookie-parser appears to have been called on a request object. It is designed to parse Set-Cookie headers from responses, not Cookie headers from requests. Set the option {silent: true} to suppress this warning."
+        );
+      }
+      input = sch;
+    }
+  }
+  if (!Array.isArray(input)) {
+    input = [input];
+  }
+  options = options ? Object.assign({}, defaultParseOptions, options) : defaultParseOptions;
+  if (!options.map) {
+    return input.filter(isNonEmptyString).map(function(str) {
+      return parseString(str, options);
+    });
+  } else {
+    var cookies = {};
+    return input.filter(isNonEmptyString).reduce(function(cookies2, str) {
+      var cookie = parseString(str, options);
+      cookies2[cookie.name] = cookie;
+      return cookies2;
+    }, cookies);
+  }
+}
+function splitCookiesString(cookiesString) {
+  if (Array.isArray(cookiesString)) {
+    return cookiesString;
+  }
+  if (typeof cookiesString !== "string") {
+    return [];
+  }
+  var cookiesStrings = [];
+  var pos = 0;
+  var start;
+  var ch;
+  var lastComma;
+  var nextStart;
+  var cookiesSeparatorFound;
+  function skipWhitespace() {
+    while (pos < cookiesString.length && /\s/.test(cookiesString.charAt(pos))) {
+      pos += 1;
+    }
+    return pos < cookiesString.length;
+  }
+  function notSpecialChar() {
+    ch = cookiesString.charAt(pos);
+    return ch !== "=" && ch !== ";" && ch !== ",";
+  }
+  while (pos < cookiesString.length) {
+    start = pos;
+    cookiesSeparatorFound = false;
+    while (skipWhitespace()) {
+      ch = cookiesString.charAt(pos);
+      if (ch === ",") {
+        lastComma = pos;
+        pos += 1;
+        skipWhitespace();
+        nextStart = pos;
+        while (pos < cookiesString.length && notSpecialChar()) {
+          pos += 1;
+        }
+        if (pos < cookiesString.length && cookiesString.charAt(pos) === "=") {
+          cookiesSeparatorFound = true;
+          pos = nextStart;
+          cookiesStrings.push(cookiesString.substring(start, lastComma));
+          start = pos;
+        } else {
+          pos = lastComma + 1;
+        }
+      } else {
+        pos += 1;
+      }
+    }
+    if (!cookiesSeparatorFound || pos >= cookiesString.length) {
+      cookiesStrings.push(cookiesString.substring(start, cookiesString.length));
+    }
+  }
+  return cookiesStrings;
+}
+setCookie.exports = parse;
+setCookie.exports.parse = parse;
+var parseString_1 = setCookie.exports.parseString = parseString;
+var splitCookiesString_1 = setCookie.exports.splitCookiesString = splitCookiesString;
+function QwikAuthQrl(authOptions) {
+  const useSignIn = globalActionQrl(/* @__PURE__ */ inlinedQrl(async ({ providerId, redirectTo: _redirectTo, options, authorizationParams }, req) => {
+    const [authOptions2] = useLexicalScope();
+    const { redirectTo = _redirectTo ?? defaultRedirectTo(req), ...rest } = options ?? {};
+    const isCredentials = providerId === "credentials";
+    const authOpts = await authOptions2(req);
+    setEnvDefaults(req.env, authOpts);
+    const body = new URLSearchParams({
+      redirectTo
+    });
+    Object.entries(rest).forEach(([key, value]) => {
+      body.set(key, String(value));
+    });
+    const baseSignInUrl = `/auth/${isCredentials ? "callback" : "signin"}${providerId ? `/${providerId}` : ""}`;
+    const signInUrl = `${baseSignInUrl}?${new URLSearchParams(authorizationParams)}`;
+    const data = await authAction(body, req, signInUrl, authOpts);
+    req.cookie.set("authjs.callback-url", redirectTo, {
+      path: "/"
+    });
+    if (data.url)
+      throw req.redirect(301, data.url);
+  }, "QwikAuthQrl_useSignIn_globalAction_xjVnyrcqS90", [
+    authOptions
+  ]), zodQrl(/* @__PURE__ */ inlinedQrl({
+    providerId: z.string().optional(),
+    /** Yoooo */
+    redirectTo: z.string().optional(),
+    options: z.object({
+      redirectTo: z.string()
+    }).passthrough().partial().optional(),
+    authorizationParams: z.union([
+      z.string(),
+      z.custom(),
+      z.record(z.string())
+    ]).optional()
+  }, "QwikAuthQrl_useSignIn_globalAction_zod_X0EcrMISJRM")));
+  const useSignOut = globalActionQrl(/* @__PURE__ */ inlinedQrl(async ({ redirectTo }, req) => {
+    const [authOptions2] = useLexicalScope();
+    redirectTo ?? (redirectTo = defaultRedirectTo(req));
+    const authOpts = await authOptions2(req);
+    setEnvDefaults(req.env, authOpts);
+    const body = new URLSearchParams({
+      redirectTo
+    });
+    await authAction(body, req, `/auth/signout`, authOpts);
+  }, "QwikAuthQrl_useSignOut_globalAction_ah1IDwV91Ag", [
+    authOptions
+  ]), zodQrl(/* @__PURE__ */ inlinedQrl({
+    redirectTo: z.string().optional()
+  }, "QwikAuthQrl_useSignOut_globalAction_zod_R188QAWPJFs")));
+  const useSession = routeLoaderQrl(/* @__PURE__ */ inlinedQrl((req) => {
+    return req.sharedMap.get("session");
+  }, "QwikAuthQrl_useSession_routeLoader_4AFWl3chA98"));
+  const onRequest = async (req) => {
+    if (isServer) {
+      const prefix = "/auth";
+      const action = req.url.pathname.slice(prefix.length + 1).split("/")[0];
+      const authOpts = await authOptions(req);
+      setEnvDefaults(req.env, authOpts);
+      if (isAuthAction(action) && req.url.pathname.startsWith(prefix + "/")) {
+        const res = await Auth(req.request, authOpts);
+        const cookie = res.headers.get("set-cookie");
+        if (cookie) {
+          req.headers.set("set-cookie", cookie);
+          res.headers.delete("set-cookie");
+          fixCookies(req);
+        }
+        throw req.send(res);
+      } else {
+        const { data, cookie } = await getSessionData(req.request, authOpts);
+        req.sharedMap.set("session", data);
+        if (cookie) {
+          req.headers.set("set-cookie", cookie);
+          fixCookies(req);
+        }
+      }
+    }
+  };
+  return {
+    useSignIn,
+    useSignOut,
+    useSession,
+    onRequest
+  };
+}
+const QwikAuth$ = /* @__PURE__ */ implicit$FirstArg(QwikAuthQrl);
+async function authAction(body, req, path, authOptions) {
+  const request = new Request(new URL(path, req.request.url), {
+    method: req.request.method,
+    headers: req.request.headers,
+    body
+  });
+  request.headers.set("content-type", "application/x-www-form-urlencoded");
+  const res = await Auth(request, authOptions);
+  const cookies = [];
+  res.headers.forEach((value, key) => {
+    if (key === "set-cookie")
+      cookies.push(value);
+    else if (!req.headers.has(key))
+      req.headers.set(key, value);
+  });
+  if (cookies.length > 0)
+    req.headers.set("set-cookie", cookies.join(", "));
+  fixCookies(req);
+  try {
+    return await res.json();
+  } catch (error) {
+    return await res.text();
+  }
+}
+const fixCookies = (req) => {
+  req.headers.set("set-cookie", req.headers.get("set-cookie") || "");
+  const cookie = req.headers.get("set-cookie");
+  if (cookie) {
+    req.headers.delete("set-cookie");
+    splitCookiesString_1(cookie).forEach((cookie2) => {
+      const { name, value, ...rest } = parseString_1(cookie2);
+      req.cookie.set(name, value, rest);
+    });
+  }
+};
+const defaultRedirectTo = (req) => {
+  req.url.searchParams.delete("qaction");
+  return req.url.href;
+};
+async function getSessionData(req, options) {
+  options.secret ?? (options.secret = process.env.AUTH_SECRET);
+  options.trustHost ?? (options.trustHost = true);
+  const url = new URL("/auth/session", req.url);
+  const response = await Auth(new Request(url, {
+    headers: req.headers
+  }), options);
+  const { status = 200 } = response;
+  const data = await response.json();
+  const cookie = response.headers.get("set-cookie");
+  if (!data || !Object.keys(data).length)
+    return {
+      data: null,
+      cookie
+    };
+  if (status === 200)
+    return {
+      data,
+      cookie
+    };
+  throw new Error(data.message);
+}
+const setEnvDefaults = (env, config) => {
+  config.basePath = "/auth";
+  if (!config.secret?.length) {
+    config.secret = [];
+    const secret = env.get("AUTH_SECRET");
+    if (secret)
+      config.secret.push(secret);
+    for (const i of [
+      1,
+      2,
+      3
+    ]) {
+      const secret2 = env.get(`AUTH_SECRET_${i}`);
+      if (secret2)
+        config.secret.unshift(secret2);
+    }
+  }
+  config.redirectProxyUrl ?? (config.redirectProxyUrl = env.get("AUTH_REDIRECT_PROXY_URL"));
+  config.trustHost ?? (config.trustHost = !!(env.get("AUTH_URL") ?? env.get("AUTH_TRUST_HOST") ?? env.get("VERCEL") ?? env.get("CF_PAGES") ?? env.get("NODE_ENV") !== "production"));
+  config.skipCSRFCheck = skipCSRFCheck;
+  config.providers = config.providers.map((p) => {
+    const finalProvider = typeof p === "function" ? p({}) : p;
+    const ID = finalProvider.id.toUpperCase().replace(/-/g, "_");
+    if (finalProvider.type === "oauth" || finalProvider.type === "oidc") {
+      finalProvider.clientId ?? (finalProvider.clientId = env.get(`AUTH_${ID}_ID`));
+      finalProvider.clientSecret ?? (finalProvider.clientSecret = env.get(`AUTH_${ID}_SECRET`));
+      if (finalProvider.type === "oidc")
+        finalProvider.issuer ?? (finalProvider.issuer = env.get(`AUTH_${ID}_ISSUER`));
+    } else if (finalProvider.type === "email")
+      finalProvider.apiKey ?? (finalProvider.apiKey = env.get(`AUTH_${ID}_KEY`));
+    return finalProvider;
+  });
+};
+export {
+  QwikAuth$,
+  QwikAuthQrl,
+  authAction as _auto_authAction,
+  defaultRedirectTo as _auto_defaultRedirectTo,
+  setEnvDefaults
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@auth/qwik",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "description": "Authentication for Qwik.",
   "license": "ISC",
   "author": "gioboa <giorgiob.boa@gmail.com>",
@@ -36,17 +36,17 @@
       "import": "./providers/*.js"
     }
   },
-  "qwik": "./index.qwik.mjs",
+  "qwik": "./index.qwik.js",
   "files": [
     "*.d.ts*",
     "*.js",
-    "*.mjs",
+    "*.qwik.js",
     "providers",
     "src"
   ],
   "dependencies": {
     "set-cookie-parser": "^2.6.0",
-    "@auth/core": "0.33.0"
+    "@auth/core": "0.34.0"
   },
   "devDependencies": {
     "@builder.io/qwik": "1.5.5",

package/providers/threads.d.ts

@@ -0,0 +1,3 @@
+export * from '@auth/core/providers/threads';
+export { default } from '@auth/core/providers/threads';
+//# sourceMappingURL=threads.d.ts.map

package/providers/threads.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"threads.d.ts","sourceRoot":"","sources":["../src/providers/threads.ts"],"names":[],"mappings":"AAAA,cAAc,8BAA8B,CAAA;AAC5C,OAAO,EAAE,OAAO,EAAE,MAAM,8BAA8B,CAAA"}

package/providers/threads.js

@@ -0,0 +1,2 @@
+export * from "@auth/core/providers/threads"
+export { default } from "@auth/core/providers/threads"

package/src/index.ts

@@ -129,7 +129,8 @@ export interface QwikAuthConfig extends Omit<AuthConfig, "raw"> {}
 
 export type GetSessionResult = Promise<{ data: Session | null; cookie: any }>
 
-function qwikAuthQrl(
+/** @internal */
+export function QwikAuthQrl(
   authOptions: QRL<(ev: RequestEventCommon) => QwikAuthConfig>
 ) {
   const useSignIn = globalAction$(
@@ -247,7 +248,7 @@ function qwikAuthQrl(
  * } = QwikAuth$(() => ({ providers: [GitHub] }))
  * ```
  */
-export const QwikAuth$ = /*#__PURE__*/ implicit$FirstArg(qwikAuthQrl)
+export const QwikAuth$ = /*#__PURE__*/ implicit$FirstArg(QwikAuthQrl)
 
 async function authAction(
   body: URLSearchParams | undefined,