houdini 2.0.0-next.8 → 2.0.0

package/build/{runtime-esm/router → router}/cookies.js

@@ -4,18 +4,18 @@
  * Copyright(c) 2015 Douglas Christopher Wilson
  * MIT Licensed
  */
-let __toString = Object.prototype.toString;
-let fieldContentRegExp = /^[\u0009\u0020-\u007e\u0080-\u00ff]+$/;
+const __toString = Object.prototype.toString;
+const fieldContentRegExp = /^[\u0009\u0020-\u007e\u0080-\u00ff]+$/;
 function parse(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;
+  const obj = {};
+  const opt = options || {};
+  const dec = opt.decode || decode;
   let index = 0;
   while (index < str.length) {
-    let eqIdx = str.indexOf("=", index);
+    const eqIdx = str.indexOf("=", index);
     if (eqIdx === -1) {
       break;
     }
@@ -26,7 +26,7 @@ function parse(str, options) {
       index = str.lastIndexOf(";", eqIdx - 1) + 1;
       continue;
     }
-    let key = str.slice(index, eqIdx).trim();
+    const key = str.slice(index, eqIdx).trim();
     if (void 0 === obj[key]) {
       let val = str.slice(eqIdx + 1, endIdx).trim();
       if (val.charCodeAt(0) === 34) {
@@ -39,44 +39,44 @@ function parse(str, options) {
   return obj;
 }
 function serialize(name, val, options) {
-  let opt = options || {};
-  let enc = opt.encode || encode;
+  const opt = options || {};
+  const enc = opt.encode || encode;
   if (typeof enc !== "function") {
     throw new TypeError("option encode is invalid");
   }
   if (!fieldContentRegExp.test(name)) {
     throw new TypeError("argument name is invalid");
   }
-  let value = enc(val);
+  const value = enc(val);
   if (value && !fieldContentRegExp.test(value)) {
     throw new TypeError("argument val is invalid");
   }
-  let str = name + "=" + value;
+  let str = `${name}=${value}`;
   if (opt.maxAge) {
-    let maxAge = opt.maxAge - 0;
-    if (Number.isNaN(maxAge) || !isFinite(maxAge)) {
+    const maxAge = opt.maxAge - 0;
+    if (Number.isNaN(maxAge) || !Number.isFinite(maxAge)) {
       throw new TypeError("option maxAge is invalid");
     }
-    str += "; Max-Age=" + Math.floor(maxAge);
+    str += `; Max-Age=${Math.floor(maxAge)}`;
   }
   if (opt.domain) {
     if (!fieldContentRegExp.test(opt.domain)) {
       throw new TypeError("option domain is invalid");
     }
-    str += "; Domain=" + opt.domain;
+    str += `; Domain=${opt.domain}`;
   }
   if (opt.path) {
     if (!fieldContentRegExp.test(opt.path)) {
       throw new TypeError("option path is invalid");
     }
-    str += "; Path=" + opt.path;
+    str += `; Path=${opt.path}`;
   }
   if (opt.expires) {
-    let expires = opt.expires;
+    const expires = opt.expires;
     if (!isDate(expires) || Number.isNaN(expires.valueOf())) {
       throw new TypeError("option expires is invalid");
     }
-    str += "; Expires=" + expires.toUTCString();
+    str += `; Expires=${expires.toUTCString()}`;
   }
   if (opt.httpOnly) {
     str += "; HttpOnly";
@@ -85,7 +85,7 @@ function serialize(name, val, options) {
     str += "; Secure";
   }
   if (opt.priority) {
-    let priority = typeof opt.priority === "string" ? opt.priority.toLowerCase() : opt.priority;
+    const priority = typeof opt.priority === "string" ? opt.priority.toLowerCase() : opt.priority;
     switch (priority) {
       case "low":
         str += "; Priority=Low";
@@ -101,7 +101,7 @@ function serialize(name, val, options) {
     }
   }
   if (opt.sameSite) {
-    let sameSite = typeof opt.sameSite === "string" ? opt.sameSite.toLowerCase() : opt.sameSite;
+    const sameSite = typeof opt.sameSite === "string" ? opt.sameSite.toLowerCase() : opt.sameSite;
     switch (sameSite) {
       case true:
         str += "; SameSite=Strict";
@@ -133,7 +133,7 @@ function isDate(val) {
 function tryDecode(str, decode2) {
   try {
     return decode2(str);
-  } catch (e) {
+  } catch (_e) {
     return str;
   }
 }

package/build/{runtime-esm/router → router}/jwt.js

@@ -1,14 +1,12 @@
 function base64UrlParse(s) {
   return new Uint8Array(
-    // @ts-ignore
-    Array.prototype.map.call(
-      atob(s.replace(/-/g, "+").replace(/_/g, "/").replace(/\s/g, "")),
+    Array.from(atob(s.replace(/-/g, "+").replace(/_/g, "/").replace(/\s/g, ""))).map(
       (c) => c.charCodeAt(0)
     )
   );
 }
 function base64UrlStringify(a) {
-  return btoa(String.fromCharCode.apply(0, a)).replace(/=/g, "").replace(/\+/g, "-").replace(/\//g, "_");
+  return btoa(String.fromCharCode.apply(0, Array.from(a))).replace(/=/g, "").replace(/\+/g, "-").replace(/\//g, "_");
 }
 const algorithms = {
   ES256: { name: "ECDSA", namedCurve: "P-256", hash: { name: "SHA-256" } },
@@ -44,7 +42,7 @@ function _decodePayload(raw) {
       raw += "=";
       break;
     default:
-      throw new Error("Illegal base64url string!" + raw);
+      throw new Error(`Illegal base64url string!${raw}`);
   }
   try {
     return JSON.parse(decodeURIComponent(escape(atob(raw))));
@@ -79,7 +77,11 @@ async function encode(payload, secret, options = { algorithm: "HS256", header: {
     );
   } 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));
+  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 }) {

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

@@ -1,5 +1,5 @@
-import type { ProjectManifest, PageManifest, QueryManifest } from '../../runtime/lib/types';
-import type { Config } from '../config';
+import type { Config } from '../lib/config.js';
+import type { ProjectManifest, PageManifest, QueryManifest } from '../lib/types.js';
 export type { ProjectManifest, PageManifest, QueryManifest };
 /**
  * Walk down the routes directory and build a normalized description of the project's

package/build/router/manifest.js

@@ -0,0 +1,279 @@
+import * as t from "@babel/types";
+import * as graphql from "graphql";
+import * as fs from "../lib/fs.js";
+import { unwrapType } from "../lib/graphql.js";
+import { parseJS } from "../lib/parse.js";
+import * as path from "../lib/path.js";
+import {
+  read_layoutQuery,
+  read_layoutView,
+  read_pageView,
+  read_pageQuery,
+  page_id
+} from "./conventions.js";
+import { parse_page_pattern } from "./match.js";
+async function load_manifest(args) {
+  const manifest = await walk_routes({
+    config: args.config,
+    url: "/",
+    filepath: args.config.routes_dir,
+    project: {
+      component_fields: {},
+      pages: {},
+      layouts: {},
+      page_queries: {},
+      layout_queries: {},
+      artifacts: [],
+      local_schema: false,
+      local_yoga: false
+    },
+    queries: [],
+    layouts: [],
+    variables: {}
+  });
+  if (args.includeArtifacts) {
+    try {
+      for (const artifactPath of await fs.readdir(args.config.artifact_dir)) {
+        if (!artifactPath.endsWith(".js") || artifactPath === "index.js") {
+          continue;
+        }
+        manifest.artifacts.push(artifactPath.substring(0, artifactPath.length - 3));
+      }
+    } catch {
+    }
+  }
+  try {
+    await fs.stat(args.config.localApiDir);
+    for (const child of await fs.readdir(args.config.localApiDir, {
+      withFileTypes: true
+    })) {
+      const name = child.isDirectory() ? child.name : path.parse(child.name).name;
+      if (name === "+schema") {
+        manifest.local_schema = true;
+      } else if (name === "+yoga") {
+        manifest.local_yoga = true;
+      }
+    }
+  } catch {
+  }
+  return manifest;
+}
+async function walk_routes(args) {
+  const directory_contents = await fs.readdir(args.filepath, {
+    withFileTypes: true
+  });
+  const variables = { ...args.variables };
+  let newLayouts = args.layouts;
+  let newLayoutQueries = args.queries;
+  let layout = null;
+  let layoutQuery = null;
+  let pageQuery = null;
+  const [
+    [layoutQueryPath, layoutQueryContents],
+    [layoutViewPath, layoutViewContents],
+    [pageQueryPath, pageQueryContents],
+    [pageViewPath, pageViewContents]
+  ] = await Promise.all([
+    read_layoutQuery(args.filepath),
+    read_layoutView(args.filepath),
+    read_pageQuery(args.filepath),
+    read_pageView(args.filepath)
+  ]);
+  if (layoutQueryContents) {
+    layoutQuery = await add_query({
+      path: layoutQueryPath,
+      config: args.config,
+      url: args.url,
+      project: args.project,
+      type: "layout",
+      contents: layoutQueryContents,
+      variables
+    });
+    newLayoutQueries = [...args.queries, layoutQuery.name];
+  }
+  if (layoutViewContents) {
+    layout = await add_view({
+      url: args.url,
+      path: layoutViewPath,
+      project: args.project,
+      type: "layout",
+      contents: layoutViewContents,
+      layouts: args.layouts,
+      queries: newLayoutQueries,
+      config: args.config,
+      variables
+    });
+    newLayouts = [...args.layouts, page_id(layout.url)];
+  }
+  if (pageQueryContents) {
+    pageQuery = await add_query({
+      path: pageQueryPath,
+      config: args.config,
+      url: args.url,
+      project: args.project,
+      type: "page",
+      contents: pageQueryContents,
+      variables
+    });
+  }
+  if (pageViewContents) {
+    await add_view({
+      path: pageViewPath,
+      url: args.url.substring(0, args.url.length - 1) || "/",
+      project: args.project,
+      type: "page",
+      contents: pageViewContents,
+      layouts: newLayouts,
+      queries: pageQuery ? [...newLayoutQueries, pageQuery.name] : newLayoutQueries,
+      config: args.config,
+      variables
+    });
+  }
+  await Promise.all(
+    directory_contents.map((dir) => {
+      if (!dir.isDirectory()) {
+        return null;
+      }
+      return walk_routes({
+        ...args,
+        filepath: path.join(args.filepath, dir.name),
+        url: `${args.url}${dir.name}/`,
+        queries: newLayoutQueries,
+        layouts: newLayouts,
+        variables
+      });
+    })
+  );
+  return args.project;
+}
+async function add_view(args) {
+  const target = args.type === "page" ? args.project.pages : args.project.layouts;
+  const queries = await extractQueries(args.contents);
+  const missing_queries = queries.filter((query) => !args.queries.includes(query));
+  if (missing_queries.length > 0) {
+    throw {
+      message: `Unknown queries in ${args.path}: ${missing_queries.join(", ")}`
+    };
+  }
+  const id = page_id(args.url);
+  target[id] = {
+    id,
+    queries,
+    url: args.url,
+    layouts: args.layouts,
+    path: path.relative(args.config.root_dir, args.path),
+    query_options: args.queries,
+    params: Object.fromEntries(
+      parse_page_pattern(args.url).params.map((param) => [
+        param.name,
+        args.variables[param.name] ?? null
+      ])
+    )
+  };
+  return target[id];
+}
+async function add_query(args) {
+  const parsed = graphql.parse(args.contents);
+  const query = parsed.definitions.find(
+    (def) => def.kind === "OperationDefinition" && def.operation === "query"
+  );
+  if (!query?.name) {
+    throw new Error("No query found");
+  }
+  let loading = false;
+  await graphql.visit(parsed, {
+    Directive(node) {
+      if (node.name.value === "loading") {
+        loading = true;
+      }
+    }
+  });
+  const queryVariables = Object.fromEntries(
+    query.variableDefinitions?.map((variable) => {
+      const { type, wrappers } = unwrapType(args.config, variable.type, [], true);
+      return [
+        variable.variable.name.value,
+        { wrappers, type: type.name }
+      ];
+    }) ?? []
+  );
+  Object.assign(args.variables, queryVariables);
+  const target = args.type === "page" ? args.project.page_queries : args.project.layout_queries;
+  target[page_id(args.url)] = {
+    path: path.relative(args.config.routes_dir, args.path),
+    name: query.name.value,
+    url: args.url,
+    loading,
+    variables: queryVariables
+  };
+  return target[page_id(args.url)];
+}
+async function extractQueries(source) {
+  const ast = parseJS(source, { plugins: ["jsx"] });
+  let defaultExportNode = null;
+  let defaultExportIdentifier = null;
+  for (const n of ast.body) {
+    const node = n;
+    if (t.isExportDefaultDeclaration(node)) {
+      if (t.isFunctionDeclaration(node.declaration) || t.isArrowFunctionExpression(node.declaration) || t.isFunctionExpression(node.declaration)) {
+        defaultExportNode = node.declaration;
+        break;
+      } else if (t.isIdentifier(node.declaration)) {
+        defaultExportIdentifier = node.declaration.name;
+      }
+    }
+  }
+  if (defaultExportIdentifier) {
+    for (const n of ast.body) {
+      const node = n;
+      if (t.isVariableDeclaration(node)) {
+        for (const declaration of node.declarations) {
+          if (t.isVariableDeclarator(declaration) && t.isIdentifier(declaration.id) && declaration.id.name === defaultExportIdentifier) {
+            if (t.isArrowFunctionExpression(declaration.init) || t.isFunctionExpression(declaration.init)) {
+              defaultExportNode = declaration.init;
+              break;
+            } else if (t.isTSAsExpression(declaration.init) && (t.isArrowFunctionExpression(declaration.init.expression) || t.isFunctionExpression(declaration.init.expression))) {
+              defaultExportNode = declaration.init.expression;
+              break;
+            }
+          }
+        }
+      }
+    }
+  }
+  if (!defaultExportNode) {
+    return [];
+  }
+  const props = [];
+  const componentFunction = defaultExportNode;
+  if (componentFunction && componentFunction.params.length > 0) {
+    const firstParam = componentFunction.params[0];
+    if (t.isObjectPattern(firstParam)) {
+      for (const property of firstParam.properties) {
+        if (t.isObjectProperty(property) && t.isIdentifier(property.key)) {
+          props.push(property.key.name);
+        }
+      }
+    } else {
+      throw new Error("Props should be specified as an object pattern.");
+    }
+  } else {
+    return [];
+  }
+  return props.reduce((queries, query) => {
+    if (query === "children") {
+      return queries;
+    }
+    if (query.endsWith("$handle")) {
+      query = query.substring(0, query.length - "$handle".length);
+    }
+    if (queries.includes(query)) {
+      return queries;
+    }
+    return queries.concat([query]);
+  }, []);
+}
+export {
+  extractQueries,
+  load_manifest
+};

package/build/{runtime/router → router}/match.d.ts

@@ -1,18 +1,16 @@
-import type { GraphQLVariables } from '$houdini/runtime/lib/types';
-import { type ConfigFile } from '../lib';
-import type { RouterManifest, RouterPageManifest } from './types';
+import type { RouterManifest, RouterPageManifest } from './types.js';
+type GraphQLScalar = string | number | boolean | null;
+type GraphQLVariables = Record<string, GraphQLScalar | GraphQLScalar[]> | null;
 export type RouteParam = {
     name: string;
-    matcher: string;
     optional: boolean;
     rest: boolean;
     chained: boolean;
+    type?: string;
 };
-export interface ParamMatcher {
-    (param: string): boolean;
-}
-export declare function find_match<_ComponentType>(config: ConfigFile, manifest: RouterManifest<_ComponentType>, current: string, allowNull: true): [RouterPageManifest<_ComponentType> | null, GraphQLVariables];
-export declare function find_match<_ComponentType>(config: ConfigFile, manifest: RouterManifest<_ComponentType>, current: string, allowNull?: false): [RouterPageManifest<_ComponentType>, GraphQLVariables];
+export declare function find_prefix_match<_ComponentType>(manifest: RouterManifest<_ComponentType>, url: string): RouterPageManifest<_ComponentType> | null;
+export declare function find_match<_ComponentType>(manifest: RouterManifest<_ComponentType>, current: string, allowNull: true): [RouterPageManifest<_ComponentType> | null, GraphQLVariables, Record<string, any>];
+export declare function find_match<_ComponentType>(manifest: RouterManifest<_ComponentType>, current: string, allowNull?: false): [RouterPageManifest<_ComponentType>, GraphQLVariables, Record<string, any>];
 /**
  * Creates the regex pattern, extracts parameter names, and generates types for a route
  */
@@ -27,7 +25,9 @@ export declare function parse_page_pattern(id: string): {
  * and will be returned as `['']`.
  */
 export declare function get_route_segments(route: string): string[];
-export declare function exec(match: RegExpMatchArray, params: RouteParam[]): Record<string, string> | undefined;
+export declare function exec(match: RegExpMatchArray, params: readonly RouteParam[]): Record<string, string> | undefined;
+export declare function parseScalar(type: string, value?: string): string | number | boolean | undefined;
+export {};
 /**
 Copyright (c) 2020 [these people](https://github.com/sveltejs/kit/graphs/contributors)
 

package/build/router/match.js

@@ -0,0 +1,219 @@
+const param_pattern = /^(\[)?(\.\.\.)?(\w+)(\])?$/;
+function find_prefix_match(manifest, url) {
+  const path = url.split("?")[0];
+  const urlSegments = path.split("/").filter(Boolean);
+  let best = null;
+  let bestCount = -1;
+  for (const page of Object.values(manifest.pages)) {
+    const pageSegments = page.url.split("/").filter(Boolean);
+    let staticCount = 0;
+    for (const seg of pageSegments) {
+      if (seg.startsWith("[") || seg.startsWith("(") || seg === "*") break;
+      staticCount++;
+    }
+    if (staticCount > urlSegments.length) continue;
+    let matches = true;
+    for (let i = 0; i < staticCount; i++) {
+      if (pageSegments[i] !== urlSegments[i]) {
+        matches = false;
+        break;
+      }
+    }
+    if (matches && staticCount > bestCount) {
+      bestCount = staticCount;
+      best = page;
+    }
+  }
+  return best;
+}
+function find_match(manifest, current, allowNull = true) {
+  const queryIndex = current.indexOf("?");
+  const path = queryIndex === -1 ? current : current.slice(0, queryIndex);
+  const search = queryIndex === -1 ? "" : current.slice(queryIndex + 1);
+  let match = null;
+  let matchVariables = null;
+  for (const page of Object.values(manifest.pages)) {
+    const urlMatch = path.match(page.pattern);
+    if (!urlMatch) {
+      continue;
+    }
+    match = page;
+    matchVariables = exec(urlMatch, page.params) || {};
+    break;
+  }
+  if (!match && !allowNull) {
+    throw new Error("404");
+  }
+  const variables = {
+    ...matchVariables
+  };
+  for (const document of Object.values(match?.documents ?? {})) {
+    for (const [variable, { type }] of Object.entries(document.variables)) {
+      if (matchVariables?.[variable]) {
+        variables[variable] = parseScalar(
+          type,
+          matchVariables[variable]
+        );
+      }
+    }
+  }
+  const searchObject = {};
+  if (search) {
+    const searchParams = new URLSearchParams(search);
+    for (const key of new Set(searchParams.keys())) {
+      const values = searchParams.getAll(key);
+      searchObject[key] = values.length > 1 ? values : values[0];
+    }
+    for (const { name, type, wrappers } of match?.searchParams ?? []) {
+      if (variables[name] != null) {
+        continue;
+      }
+      if (wrappers.includes("List")) {
+        const raw = searchParams.getAll(name);
+        if (raw.length === 0) {
+          continue;
+        }
+        variables[name] = raw.map((value) => parseScalar(type, value)).filter((value) => value !== void 0);
+      } else if (searchParams.has(name)) {
+        const parsed = parseScalar(type, searchParams.get(name) ?? void 0);
+        if (parsed !== void 0) {
+          variables[name] = parsed;
+        }
+      }
+      if (name in searchObject && variables[name] != null) {
+        searchObject[name] = variables[name];
+      }
+    }
+  }
+  return [match, variables, searchObject];
+}
+function parse_page_pattern(id) {
+  const params = [];
+  const pattern = id === "/" ? /^\/$/ : new RegExp(
+    `^${get_route_segments(id).map((segment) => {
+      const rest_match = /^\[\.\.\.(\w+)\]$/.exec(segment);
+      if (rest_match) {
+        params.push({
+          name: rest_match[1],
+          optional: false,
+          rest: true,
+          chained: true
+        });
+        return "(?:/(.*))?";
+      }
+      const optional_match = /^\[\[(\w+)\]\]$/.exec(segment);
+      if (optional_match) {
+        params.push({
+          name: optional_match[1],
+          optional: true,
+          rest: false,
+          chained: true
+        });
+        return "(?:/([^/]+))?";
+      }
+      if (!segment) {
+        return "";
+      }
+      const parts = segment.split(/\[(.+?)\](?!\])/);
+      const result = parts.map((content, i) => {
+        if (i % 2) {
+          if (content.startsWith("x+")) {
+            return escapeRegex(
+              String.fromCharCode(parseInt(content.slice(2), 16))
+            );
+          }
+          if (content.startsWith("u+")) {
+            return escapeRegex(
+              String.fromCharCode(
+                ...content.slice(2).split("-").map((code) => parseInt(code, 16))
+              )
+            );
+          }
+          const match = param_pattern.exec(content);
+          if (!match) {
+            throw new Error(
+              `Invalid param: ${content}. Params can only have underscores and alphanumeric characters.`
+            );
+          }
+          const [, is_optional, is_rest, name] = match;
+          params.push({
+            name,
+            optional: !!is_optional,
+            rest: !!is_rest,
+            chained: is_rest ? i === 1 && parts[0] === "" : false
+          });
+          return is_rest ? "(.*?)" : is_optional ? "([^/]*)?" : "([^/]+?)";
+        }
+        return escapeRegex(content);
+      }).join("");
+      return `/${result}`;
+    }).join("")}/?$`
+  );
+  return { pattern, params, page_id: id };
+}
+function affects_path(segment) {
+  return !/^\([^)]+\)$/.test(segment);
+}
+function get_route_segments(route) {
+  return route.slice(1).split("/").filter(affects_path);
+}
+function exec(match, params) {
+  const result = {};
+  const values = match.slice(1);
+  let buffered = "";
+  for (let i = 0; i < (params || []).length; i += 1) {
+    const param = params[i];
+    let value = values[i];
+    if (param.chained && param.rest && buffered) {
+      value = value ? `${buffered}/${value}` : buffered;
+    }
+    buffered = "";
+    if (value === void 0) {
+      if (param.rest) result[param.name] = "";
+    } else {
+      result[param.name] = decodeURIComponent(value);
+    }
+  }
+  if (buffered) return;
+  return result;
+}
+function escapeRegex(str) {
+  return str.normalize().replace(/[[\]]/g, "\\$&").replace(/%/g, "%25").replace(/\//g, "%2[Ff]").replace(/\?/g, "%3[Ff]").replace(/#/g, "%23").replace(/[.*+?^${}()|\\]/g, "\\$&");
+}
+function parseScalar(type, value) {
+  if (typeof value === "undefined") {
+    return void 0;
+  }
+  if (type === "Boolean") {
+    return value === "true";
+  }
+  if (type === "ID") {
+    return value;
+  }
+  if (type === "String") {
+    return value;
+  }
+  if (type === "Int") {
+    const result = parseInt(value, 10);
+    if (Number.isNaN(result)) {
+      return void 0;
+    }
+    return result;
+  }
+  if (type === "Float") {
+    const result = parseFloat(value);
+    if (Number.isNaN(result)) {
+      return void 0;
+    }
+    return result;
+  }
+  return value;
+}
+export {
+  exec,
+  find_match,
+  find_prefix_match,
+  get_route_segments,
+  parseScalar,
+  parse_page_pattern
+};