houdini 1.2.10 → 1.2.11

package/build/lib-esm/index.js

@@ -1483,7 +1483,7 @@ var require_parser = __commonJS({
     Object.defineProperty(exports, "__esModule", {
       value: true
     });
-    exports.parse = parse5;
+    exports.parse = parse6;
     exports.parseValue = parseValue;
     exports.parseType = parseType;
     exports.Parser = void 0;
@@ -1494,7 +1494,7 @@ var require_parser = __commonJS({
     var _source = require_source();
     var _directiveLocation = require_directiveLocation();
     var _lexer = require_lexer();
-    function parse5(source, options) {
+    function parse6(source, options) {
       var parser = new Parser(source, options);
       return parser.parseDocument();
     }
@@ -32886,14 +32886,14 @@ var require_lib3 = __commonJS({
         super.checkParams(node, false, true);
         this.scope.exit();
       }
-      forwardNoArrowParamsConversionAt(node, parse6) {
+      forwardNoArrowParamsConversionAt(node, parse7) {
         let result;
         if (this.state.noArrowParamsConversionAt.indexOf(node.start) !== -1) {
           this.state.noArrowParamsConversionAt.push(this.state.start);
-          result = parse6();
+          result = parse7();
           this.state.noArrowParamsConversionAt.pop();
         } else {
-          result = parse6();
+          result = parse7();
         }
         return result;
       }
@@ -41948,7 +41948,7 @@ var require_lib3 = __commonJS({
       }
       return pluginMap;
     }
-    function parse5(input, options) {
+    function parse6(input, options) {
       var _options;
       if (((_options = options) == null ? void 0 : _options.sourceType) === "unambiguous") {
         options = Object.assign({}, options);
@@ -42018,7 +42018,7 @@ var require_lib3 = __commonJS({
       }
       return cls;
     }
-    exports.parse = parse5;
+    exports.parse = parse6;
     exports.parseExpression = parseExpression;
     exports.tokTypes = tokTypes;
   }
@@ -47964,7 +47964,7 @@ var require_esprima2 = __commonJS({
           var jsx_parser_1 = __webpack_require__(3);
           var parser_1 = __webpack_require__(8);
           var tokenizer_1 = __webpack_require__(15);
-          function parse5(code, options, delegate) {
+          function parse6(code, options, delegate) {
             var commentHandler = null;
             var proxyDelegate = function(node, metadata) {
               if (delegate) {
@@ -48009,17 +48009,17 @@ var require_esprima2 = __commonJS({
             }
             return ast;
           }
-          exports2.parse = parse5;
+          exports2.parse = parse6;
           function parseModule(code, options, delegate) {
             var parsingOptions = options || {};
             parsingOptions.sourceType = "module";
-            return parse5(code, parsingOptions, delegate);
+            return parse6(code, parsingOptions, delegate);
           }
           exports2.parseModule = parseModule;
           function parseScript(code, options, delegate) {
             var parsingOptions = options || {};
             parsingOptions.sourceType = "script";
-            return parse5(code, parsingOptions, delegate);
+            return parse6(code, parsingOptions, delegate);
           }
           exports2.parseScript = parseScript;
           function tokenize(code, options, delegate) {
@@ -54083,7 +54083,7 @@ var require_esprima3 = __commonJS({
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.parse = void 0;
     var util_1 = require_util2();
-    function parse5(source, options) {
+    function parse6(source, options) {
       var comments = [];
       var ast = require_esprima2().parse(source, {
         loc: true,
@@ -54101,7 +54101,7 @@ var require_esprima3 = __commonJS({
       }
       return ast;
     }
-    exports.parse = parse5;
+    exports.parse = parse6;
   }
 });
 
@@ -55223,7 +55223,7 @@ var require_parser2 = __commonJS({
     var lines_1 = require_lines();
     var comments_1 = require_comments();
     var util = tslib_1.__importStar(require_util2());
-    function parse5(source, options) {
+    function parse6(source, options) {
       options = (0, options_1.normalize)(options);
       var lines = (0, lines_1.fromString)(source, options);
       var sourceWithoutTabs = lines.toString({
@@ -55295,7 +55295,7 @@ var require_parser2 = __commonJS({
       (0, comments_1.attach)(comments, program.body.length ? file.program : file, lines);
       return new TreeCopier(lines, tokens).copy(file);
     }
-    exports.parse = parse5;
+    exports.parse = parse6;
     var TreeCopier = function TreeCopier2(lines, tokens) {
       assert_1.default.ok(this instanceof TreeCopier2);
       this.lines = lines;
@@ -82246,7 +82246,7 @@ var defaultDirectives = emptySchema.getDirectives().map((dir) => dir.name);
 
 // src/lib/graphql.ts
 var graphql3 = __toESM(require_graphql2(), 1);
-import crypto from "node:crypto";
+import crypto2 from "node:crypto";
 function getRootType(type) {
   if (graphql3.isNonNullType(type)) {
     return getRootType(type.ofType);
@@ -82263,7 +82263,7 @@ function hashRaw({ document }) {
   return hashDocument(document.artifact?.raw);
 }
 function hashDocument(str) {
-  return crypto.createHash("sha256").update(str || "").digest("hex");
+  return crypto2.createHash("sha256").update(str || "").digest("hex");
 }
 function parentField(ancestors) {
   return walkParentField([...ancestors].sort(() => -1));
@@ -82766,7 +82766,7 @@ async function find_graphql(config2, parsedScript, walker) {
   });
 }
 
-// src/lib/router/conventions.ts
+// src/router/conventions.ts
 var conventions_exports = {};
 __export(conventions_exports, {
   fallback_unit_path: () => fallback_unit_path,
@@ -82884,7 +82884,7 @@ function serialized_manifest_path(config2, base = base_dir(config2)) {
   return path_exports.join(base, "manifest.json");
 }
 
-// src/lib/router/manifest.ts
+// src/router/manifest.ts
 var t2 = __toESM(require_lib6(), 1);
 var graphql5 = __toESM(require_graphql2(), 1);
 async function load_manifest(args) {
@@ -83092,6 +83092,251 @@ async function extractQueries(source) {
   }
   return props.filter((p) => p !== "children");
 }
+
+// src/runtime/router/cookies.ts
+function parse5(str, options) {
+  if (typeof str !== "string") {
+    throw new TypeError("argument str must be a string");
+  }
+  let obj = {};
+  let opt = options || {};
+  let dec = opt.decode || decode;
+  let index = 0;
+  while (index < str.length) {
+    let eqIdx = str.indexOf("=", index);
+    if (eqIdx === -1) {
+      break;
+    }
+    let endIdx = str.indexOf(";", index);
+    if (endIdx === -1) {
+      endIdx = str.length;
+    } else if (endIdx < eqIdx) {
+      index = str.lastIndexOf(";", eqIdx - 1) + 1;
+      continue;
+    }
+    let key = str.slice(index, eqIdx).trim();
+    if (void 0 === obj[key]) {
+      let val = str.slice(eqIdx + 1, endIdx).trim();
+      if (val.charCodeAt(0) === 34) {
+        val = val.slice(1, -1);
+      }
+      obj[key] = tryDecode(val, dec);
+    }
+    index = endIdx + 1;
+  }
+  return obj;
+}
+function decode(str) {
+  return str.indexOf("%") !== -1 ? decodeURIComponent(str) : str;
+}
+function tryDecode(str, decode3) {
+  try {
+    return decode3(str);
+  } catch (e2) {
+    return str;
+  }
+}
+
+// src/runtime/router/jwt.ts
+function base64UrlParse(s2) {
+  return new Uint8Array(
+    Array.prototype.map.call(
+      atob(s2.replace(/-/g, "+").replace(/_/g, "/").replace(/\s/g, "")),
+      (c) => c.charCodeAt(0)
+    )
+  );
+}
+function base64UrlStringify(a) {
+  return btoa(String.fromCharCode.apply(0, a)).replace(/=/g, "").replace(/\+/g, "-").replace(/\//g, "_");
+}
+var algorithms = {
+  ES256: { name: "ECDSA", namedCurve: "P-256", hash: { name: "SHA-256" } },
+  ES384: { name: "ECDSA", namedCurve: "P-384", hash: { name: "SHA-384" } },
+  ES512: { name: "ECDSA", namedCurve: "P-521", hash: { name: "SHA-512" } },
+  HS256: { name: "HMAC", hash: { name: "SHA-256" } },
+  HS384: { name: "HMAC", hash: { name: "SHA-384" } },
+  HS512: { name: "HMAC", hash: { name: "SHA-512" } },
+  RS256: { name: "RSASSA-PKCS1-v1_5", hash: { name: "SHA-256" } },
+  RS384: { name: "RSASSA-PKCS1-v1_5", hash: { name: "SHA-384" } },
+  RS512: { name: "RSASSA-PKCS1-v1_5", hash: { name: "SHA-512" } }
+};
+function _utf8ToUint8Array(str) {
+  return base64UrlParse(btoa(unescape(encodeURIComponent(str))));
+}
+function _str2ab(str) {
+  str = atob(str);
+  const buf = new ArrayBuffer(str.length);
+  const bufView = new Uint8Array(buf);
+  for (let i2 = 0, strLen = str.length; i2 < strLen; i2++) {
+    bufView[i2] = str.charCodeAt(i2);
+  }
+  return buf;
+}
+function _decodePayload(raw) {
+  switch (raw.length % 4) {
+    case 0:
+      break;
+    case 2:
+      raw += "==";
+      break;
+    case 3:
+      raw += "=";
+      break;
+    default:
+      throw new Error("Illegal base64url string!");
+  }
+  try {
+    return JSON.parse(decodeURIComponent(escape(atob(raw))));
+  } catch {
+    return null;
+  }
+}
+async function encode(payload, secret, options = { algorithm: "HS256", header: { typ: "JWT" } }) {
+  if (typeof options === "string")
+    options = { algorithm: options, header: { typ: "JWT" } };
+  options = { algorithm: "HS256", header: { typ: "JWT" }, ...options };
+  if (payload === null || typeof payload !== "object")
+    throw new Error("payload must be an object");
+  if (typeof secret !== "string" && typeof secret !== "object")
+    throw new Error("secret must be a string or a JWK object");
+  if (typeof options.algorithm !== "string")
+    throw new Error("options.algorithm must be a string");
+  const algorithm = algorithms[options.algorithm];
+  if (!algorithm)
+    throw new Error("algorithm not found");
+  if (!payload.iat)
+    payload.iat = Math.floor(Date.now() / 1e3);
+  const payloadAsJSON = JSON.stringify(payload);
+  const partialToken = `${base64UrlStringify(
+    _utf8ToUint8Array(JSON.stringify({ ...options.header, alg: options.algorithm }))
+  )}.${base64UrlStringify(_utf8ToUint8Array(payloadAsJSON))}`;
+  let keyFormat = "raw";
+  let keyData;
+  if (typeof secret === "object") {
+    keyFormat = "jwk";
+    keyData = secret;
+  } else if (typeof secret === "string" && secret.startsWith("-----BEGIN")) {
+    keyFormat = "pkcs8";
+    keyData = _str2ab(
+      secret.replace(/-----BEGIN.*?-----/g, "").replace(/-----END.*?-----/g, "").replace(/\s/g, "")
+    );
+  } else
+    keyData = _utf8ToUint8Array(secret);
+  const key = await crypto.subtle.importKey(keyFormat, keyData, algorithm, false, ["sign"]);
+  const signature = await crypto.subtle.sign(algorithm, key, _utf8ToUint8Array(partialToken));
+  return `${partialToken}.${base64UrlStringify(new Uint8Array(signature))}`;
+}
+async function verify(token, secret, options = { algorithm: "HS256", throwError: false }) {
+  if (typeof options === "string")
+    options = { algorithm: options, throwError: false };
+  options = { algorithm: "HS256", throwError: false, ...options };
+  if (typeof token !== "string")
+    throw new Error("token must be a string");
+  if (typeof secret !== "string" && typeof secret !== "object")
+    throw new Error("secret must be a string or a JWK object");
+  if (typeof options.algorithm !== "string")
+    throw new Error("options.algorithm must be a string");
+  const tokenParts = token.split(".");
+  if (tokenParts.length !== 3)
+    throw new Error("token must consist of 3 parts");
+  const algorithm = algorithms[options.algorithm];
+  if (!algorithm)
+    throw new Error("algorithm not found");
+  const { payload } = decode2(token);
+  if (!payload) {
+    if (options.throwError)
+      throw "PARSE_ERROR";
+    return false;
+  }
+  if (payload.nbf && payload.nbf > Math.floor(Date.now() / 1e3)) {
+    if (options.throwError)
+      throw "NOT_YET_VALID";
+    return false;
+  }
+  if (payload.exp && payload.exp <= Math.floor(Date.now() / 1e3)) {
+    if (options.throwError)
+      throw "EXPIRED";
+    return false;
+  }
+  let keyFormat = "raw";
+  let keyData;
+  if (typeof secret === "object") {
+    keyFormat = "jwk";
+    keyData = secret;
+  } else if (typeof secret === "string" && secret.startsWith("-----BEGIN")) {
+    keyFormat = "spki";
+    keyData = _str2ab(
+      secret.replace(/-----BEGIN.*?-----/g, "").replace(/-----END.*?-----/g, "").replace(/\s/g, "")
+    );
+  } else
+    keyData = _utf8ToUint8Array(secret);
+  const key = await crypto.subtle.importKey(keyFormat, keyData, algorithm, false, ["verify"]);
+  return await crypto.subtle.verify(
+    algorithm,
+    key,
+    base64UrlParse(tokenParts[2]),
+    _utf8ToUint8Array(`${tokenParts[0]}.${tokenParts[1]}`)
+  );
+}
+function decode2(token) {
+  return {
+    header: _decodePayload(
+      token.split(".")[0].replace(/-/g, "+").replace(/_/g, "/")
+    ),
+    payload: _decodePayload(
+      token.split(".")[1].replace(/-/g, "+").replace(/_/g, "/")
+    )
+  };
+}
+
+// src/runtime/router/server.ts
+async function handle_request(args) {
+  const plugin_config = args.config.plugins?.["houdini-react"];
+  if (plugin_config.auth && "redirect" in plugin_config.auth && args.url.startsWith(plugin_config.auth.redirect)) {
+    return await redirect_auth(args);
+  }
+  args.next();
+}
+async function redirect_auth(args) {
+  const { searchParams } = new URL(args.url, `http://${args.get_header("host")}`);
+  const { redirectTo, ...session } = Object.fromEntries(searchParams.entries());
+  await set_session(args, session);
+  if (redirectTo) {
+    return args.redirect(302, redirectTo);
+  }
+  args.next();
+}
+var session_cookie_name = "__houdini__";
+async function set_session(req, value) {
+  const today = new Date();
+  const expires = new Date(today.getTime() + 7 * 24 * 60 * 60 * 1e3);
+  const serialized = await encode(value, req.session_keys[0]);
+  req.set_header(
+    "Set-Cookie",
+    `${session_cookie_name}=${serialized}; Path=/; HttpOnly; Secure; SameSite=Lax; Expires=${expires.toUTCString()} `
+  );
+}
+async function get_session(req, secrets) {
+  const cookies = req.get("cookie");
+  if (!cookies) {
+    return {};
+  }
+  const cookie = parse5(cookies)[session_cookie_name];
+  if (!cookie) {
+    return {};
+  }
+  for (const secret of secrets) {
+    if (!await verify(cookie, secret)) {
+      continue;
+    }
+    const parsed = decode2(cookie);
+    if (!parsed) {
+      return {};
+    }
+    return parsed.payload;
+  }
+  return {};
+}
 export {
   ArtifactKind,
   Cache,
@@ -83132,6 +83377,8 @@ export {
   getCurrentConfig,
   getMockConfig,
   getRootType,
+  get_session,
+  handle_request,
   hashOriginal,
   hashRaw,
   houdini_mode,
@@ -83159,6 +83406,12 @@ export {
   unwrapType,
   wrapType
 };
+/*!
+ * cookie
+ * Copyright(c) 2012-2014 Roman Shtylman
+ * Copyright(c) 2015 Douglas Christopher Wilson
+ * MIT Licensed
+ */
 /*! fetch-blob. MIT License. Jimmy Wärting <https://jimmy.warting.se/opensource> */
 /*! formdata-polyfill. MIT License. Jimmy Wärting <https://jimmy.warting.se/opensource> */
 /*! node-domexception. MIT License. Jimmy Wärting <https://jimmy.warting.se/opensource> */

package/build/{lib/router → router}/conventions.d.ts

@@ -1,4 +1,4 @@
-import { type Config } from '../';
+import { type Config } from '../lib';
 /** The location of the project's router */
 export declare function router_path(config: Config): string;
 /** The location of the page component */

package/build/{lib/router → router}/index.d.ts

@@ -5,3 +5,4 @@
 export * as routerConventions from './conventions';
 export * from './manifest';
 export * from './types';
+export { handle_request, get_session } from '../runtime/router/server';

package/build/{lib/router → router}/manifest.d.ts

@@ -1,4 +1,4 @@
-import { type Config } from '../';
+import { type Config } from '../lib';
 /**
  * Walk down the routes directory and build a normalized description of the project's
  * filesystem.

package/build/{lib/router → router}/types.d.ts

@@ -1,5 +1,5 @@
 import type { routerConventions } from '.';
-import type { Config } from '../config';
+import type { Config } from '../lib/config';
 export type Adapter = (args: {
     config: Config;
     conventions: typeof routerConventions;