houdini 2.0.0-next.9 → 2.0.1

package/build/runtime-esm/router/match.js

@@ -1,131 +0,0 @@
-import { parseScalar } from "../lib";
-const param_pattern = /^(\[)?(\.\.\.)?(\w+)(?:=(\w+))?(\])?$/;
-function find_match(config, manifest, current, allowNull = true) {
-  let match = null;
-  let matchVariables = null;
-  for (const page of Object.values(manifest.pages)) {
-    const urlMatch = current.match(page.pattern);
-    if (!urlMatch) {
-      continue;
-    }
-    match = page;
-    matchVariables = exec(urlMatch, page.params) || {};
-    break;
-  }
-  if (!match && !allowNull) {
-    throw new Error("404");
-  }
-  let 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(config, type, matchVariables[variable]);
-      }
-    }
-  }
-  return [match, variables];
-}
-function parse_page_pattern(id) {
-  const params = [];
-  const pattern = id === "/" ? /^\/$/ : new RegExp(
-    `^${get_route_segments(id).map((segment) => {
-      const rest_match = /^\[\.\.\.(\w+)(?:=(\w+))?\]$/.exec(segment);
-      if (rest_match) {
-        params.push({
-          name: rest_match[1],
-          matcher: rest_match[2],
-          optional: false,
-          rest: true,
-          chained: true
-        });
-        return "(?:/(.*))?";
-      }
-      const optional_match = /^\[\[(\w+)(?:=(\w+))?\]\]$/.exec(segment);
-      if (optional_match) {
-        params.push({
-          name: optional_match[1],
-          matcher: optional_match[2],
-          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 escape(
-              String.fromCharCode(parseInt(content.slice(2), 16))
-            );
-          }
-          if (content.startsWith("u+")) {
-            return escape(
-              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 and matcher names can only have underscores and alphanumeric characters.`
-            );
-          }
-          const [, is_optional, is_rest, name, matcher] = match;
-          params.push({
-            name,
-            matcher,
-            optional: !!is_optional,
-            rest: !!is_rest,
-            chained: is_rest ? i === 1 && parts[0] === "" : false
-          });
-          return is_rest ? "(.*?)" : is_optional ? "([^/]*)?" : "([^/]+?)";
-        }
-        return escape(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 escape(str) {
-  return str.normalize().replace(/[[\]]/g, "\\$&").replace(/%/g, "%25").replace(/\//g, "%2[Ff]").replace(/\?/g, "%3[Ff]").replace(/#/g, "%23").replace(/[.*+?^${}()|\\]/g, "\\$&");
-}
-export {
-  exec,
-  find_match,
-  get_route_segments,
-  parse_page_pattern
-};

package/build/runtime-esm/router/server.d.ts

@@ -1,24 +0,0 @@
-import { createServerAdapter } from '@whatwg-node/server';
-import type { GraphQLSchema } from 'graphql';
-import type { HoudiniClient } from '../client';
-import { Server } from '../server';
-import type { RouterManifest, RouterPageManifest, YogaServerOptions } from './types';
-export declare function _serverHandler<ComponentType = unknown>({ schema, server, client, production, manifest, graphqlEndpoint, on_render, componentCache, }: {
-    schema?: GraphQLSchema | null;
-    server?: Server<any, any>;
-    client: HoudiniClient;
-    production: boolean;
-    manifest: RouterManifest<ComponentType> | null;
-    assetPrefix: string;
-    graphqlEndpoint: string;
-    componentCache: Record<string, any>;
-    on_render: (args: {
-        url: string;
-        match: RouterPageManifest<ComponentType> | null;
-        manifest: RouterManifest<unknown>;
-        session: App.Session;
-        componentCache: Record<string, any>;
-    }) => Response | Promise<Response | undefined> | undefined;
-} & Omit<YogaServerOptions, 'schema'>): (request: Request) => Promise<Response>;
-export declare const serverAdapterFactory: (args: Parameters<typeof _serverHandler>[0]) => ReturnType<typeof createServerAdapter>;
-export type ServerAdapterFactory = typeof serverAdapterFactory;

package/build/runtime-esm/router/server.js

@@ -1,92 +0,0 @@
-import { createServerAdapter } from "@whatwg-node/server";
-import { localApiSessionKeys, getCurrentConfig } from "../lib/config";
-import { Server } from "../server";
-import { serialize as encodeCookie } from "./cookies";
-import { find_match } from "./match";
-import { get_session, handle_request, session_cookie_name } from "./session";
-const config_file = getCurrentConfig();
-const session_keys = localApiSessionKeys(config_file);
-function _serverHandler({
-  schema,
-  server,
-  client,
-  production,
-  manifest,
-  graphqlEndpoint,
-  on_render,
-  componentCache
-}) {
-  if (schema && !server) {
-    server = new Server({
-      landingPage: !production
-    });
-  }
-  let requestHandler = null;
-  if (server && schema) {
-    requestHandler = server.init({
-      schema,
-      endpoint: graphqlEndpoint,
-      getSession: (request) => get_session(request.headers, session_keys)
-    });
-  }
-  client.componentCache = componentCache;
-  if (requestHandler) {
-    client.registerProxy(graphqlEndpoint, async ({ query, variables, session }) => {
-      const response = await requestHandler(
-        new Request(`http://localhost/${graphqlEndpoint}`, {
-          method: "POST",
-          headers: {
-            "Content-Type": "application/json",
-            Cookie: encodeCookie(session_cookie_name, JSON.stringify(session ?? {}), {
-              httpOnly: true
-            })
-          },
-          body: JSON.stringify({
-            query,
-            variables
-          })
-        })
-      );
-      return await response.json();
-    });
-  }
-  return async (request) => {
-    if (!manifest) {
-      return new Response(
-        "Adapter did not provide the project's manifest. Please open an issue on github.",
-        { status: 500 }
-      );
-    }
-    const url = new URL(request.url).pathname;
-    if (requestHandler && url === graphqlEndpoint) {
-      return requestHandler(request);
-    }
-    const authResponse = await handle_request({
-      request,
-      config: config_file,
-      session_keys
-    });
-    if (authResponse) {
-      return authResponse;
-    }
-    const [match] = find_match(config_file, manifest, url);
-    const rendered = await on_render({
-      url,
-      match,
-      session: await get_session(request.headers, session_keys),
-      manifest,
-      componentCache
-    });
-    if (rendered) {
-      return rendered;
-    }
-    return new Response("404", { status: 404 });
-  };
-}
-const serverAdapterFactory = (args) => {
-  return createServerAdapter(_serverHandler(args));
-};
-export {
-  _serverHandler,
-  serverAdapterFactory
-};

package/build/runtime-esm/router/session.d.ts

@@ -1,22 +0,0 @@
-import type { ConfigFile } from '../lib';
-type ServerHandlerArgs = {
-    request: Request;
-    config: ConfigFile;
-    session_keys: string[];
-};
-export declare function handle_request(args: ServerHandlerArgs): Promise<Response | undefined>;
-export type Server = {
-    use(fn: ServerMiddleware): void;
-};
-export type ServerMiddleware = (req: IncomingRequest, res: ServerResponse, next: () => void) => void;
-export type IncomingRequest = {
-    url?: string;
-    headers: Headers;
-};
-export type ServerResponse = {
-    redirect(url: string, status?: number): void;
-    set_header(name: string, value: string): void;
-};
-export declare const session_cookie_name = "__houdini__";
-export declare function get_session(req: Headers, secrets: string[]): Promise<App.Session>;
-export {};

package/build/runtime-esm/router/session.js

@@ -1,74 +0,0 @@
-import { parse } from "./cookies";
-import { decode, encode, verify } from "./jwt";
-async function handle_request(args) {
-  const plugin_config = args.config.router ?? {};
-  const { pathname } = new URL(args.request.url);
-  if (plugin_config.auth && "redirect" in plugin_config.auth && pathname.startsWith(plugin_config.auth.redirect)) {
-    return await redirect_auth(args);
-  }
-}
-async function redirect_auth(args) {
-  if (args.request.method === "GET") {
-    const { searchParams } = new URL(
-      args.request.url,
-      `http://${args.request.headers.get("host")}`
-    );
-    const { redirectTo, ...session } = Object.fromEntries(searchParams.entries());
-    const response = new Response("ok", {
-      status: 302,
-      headers: {
-        Location: redirectTo ?? "/"
-      }
-    });
-    await set_session(args, response, session);
-    return response;
-  }
-  if (args.request.method === "POST") {
-    const newValues = await args.request.json();
-    const existing = await get_session(args.request.headers, args.session_keys);
-    const response = new Response("ok", {
-      status: 200
-    });
-    await set_session(args, response, { ...existing, ...newValues });
-    return response;
-  }
-}
-const session_cookie_name = "__houdini__";
-async function set_session(req, response, value) {
-  const today = /* @__PURE__ */ new Date();
-  const expires = new Date(today.getTime() + 7 * 24 * 60 * 60 * 1e3);
-  const serialized = await encode(value, req.session_keys[0]);
-  response.headers.set(
-    "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 = parse(cookies)[session_cookie_name];
-  if (!cookie) {
-    return {};
-  }
-  if (cookie === "{}") {
-    return {};
-  }
-  for (const secret of secrets) {
-    if (!await verify(cookie, secret)) {
-      continue;
-    }
-    const parsed = decode(cookie);
-    if (!parsed) {
-      return {};
-    }
-    return parsed.payload;
-  }
-  return {};
-}
-export {
-  get_session,
-  handle_request,
-  session_cookie_name
-};

package/build/runtime-esm/router/types.d.ts

@@ -1,26 +0,0 @@
-import type { QueryArtifact } from '$houdini/runtime/lib/types';
-import type { createYoga } from 'graphql-yoga';
-import type { RouteParam } from './match';
-export type YogaServer = ReturnType<typeof createYoga>;
-export type YogaServerOptions = Parameters<typeof createYoga>[0];
-export type RouterManifest<_ComponentType> = {
-    pages: Record<string, RouterPageManifest<_ComponentType>>;
-};
-export type { ServerAdapterFactory } from './server';
-export type RouterPageManifest<_ComponentType> = {
-    id: string;
-    pattern: RegExp;
-    params: RouteParam[];
-    documents: Record<string, {
-        artifact: () => Promise<{
-            default: QueryArtifact;
-        }>;
-        loading: boolean;
-        variables: Record<string, {
-            type: string;
-        }>;
-    }>;
-    component: () => Promise<{
-        default: _ComponentType;
-    }>;
-};

package/build/runtime-esm/server/index.d.ts

@@ -1,17 +0,0 @@
-import type { ServerAdapterRequestHandler } from '@whatwg-node/server';
-import { YogaServer } from 'graphql-yoga';
-import type { YogaSchemaDefinition } from 'graphql-yoga/typings/plugins/use-schema';
-type YogaParams = Required<ConstructorParameters<typeof YogaServer>>[0];
-type ConstructorParams = Omit<YogaParams, 'schema' | 'graphqlEndpoint'>;
-export declare class Server<ServerContext extends Record<string, any>, UserContext extends Record<string, any>> {
-    opts: ConstructorParams | null;
-    _yoga: YogaServer<any, any> | null;
-    constructor(opts?: ConstructorParams);
-    init({ endpoint, schema, getSession, }: {
-        schema: YogaSchemaDefinition<any>;
-        endpoint: string;
-        getSession: (request: Request) => Promise<UserContext>;
-    }): import("@whatwg-node/server").ServerAdapter<ServerContext, Server<ServerContext, UserContext>>;
-    handle: ServerAdapterRequestHandler<ServerContext>;
-}
-export {};

package/build/runtime-esm/server/index.js

@@ -1,38 +0,0 @@
-import { createServerAdapter } from "@whatwg-node/server";
-import { YogaServer } from "graphql-yoga";
-class Server {
-  opts;
-  _yoga = null;
-  constructor(opts) {
-    this.opts = opts ?? null;
-  }
-  init({
-    endpoint,
-    schema,
-    getSession
-  }) {
-    this._yoga = new YogaServer({
-      ...this.opts,
-      schema,
-      graphqlEndpoint: endpoint,
-      context: async (ctx) => {
-        const userContext = !this.opts ? {} : typeof this.opts.context === "function" ? await this.opts.context(ctx) : this.opts.context || {};
-        const sessionContext = await getSession(ctx.request) || {};
-        return {
-          ...userContext,
-          session: sessionContext
-        };
-      }
-    });
-    return createServerAdapter(this, {
-      fetchAPI: this._yoga.fetchAPI,
-      plugins: this._yoga["plugins"]
-    });
-  }
-  handle = (request, serverContext) => {
-    return this._yoga.handle(request, serverContext);
-  };
-}
-export {
-  Server
-};