houdini 2.0.0-next.1 → 2.0.0-next.10

package/build/runtime-esm/cache/cache.js

@@ -387,20 +387,21 @@ class CacheInternal {
       } else if (Array.isArray(value) && // make typescript happy
       (typeof previousValue === "undefined" || previousValue === null || Array.isArray(previousValue))) {
         let oldIDs = [...previousValue || []];
-        const emptyEdges = !updates ? [] : oldIDs.map((id) => {
-          if (!id) {
-            return "";
-          }
-          const { value: cursorField } = this.storage.get(id, "cursor");
-          if (cursorField) {
-            return "";
-          }
-          const { value: node } = this.storage.get(id, "node");
-          if (!node) {
-            return "";
-          }
-          return node;
-        });
+        if (updates?.includes("append") || updates?.includes("prepend")) {
+          oldIDs = oldIDs.filter((id) => {
+            for (const layer2 of this.storage.data) {
+              for (const operation of Object.values(layer2.operations)) {
+                if (operation.fields?.[key])
+                  for (const listOperation of operation.fields[key]) {
+                    if ("id" in listOperation && listOperation.id === id) {
+                      return false;
+                    }
+                  }
+              }
+            }
+            return true;
+          });
+        }
         let linkedIDs = [];
         const { newIDs, nestedIDs } = this.extractNestedListIDs({
           value,
@@ -419,39 +420,45 @@ class CacheInternal {
           layer.writeLink(parent, key, linkedIDs);
         };
         if (applyUpdates && updates) {
-          if (key === "edges") {
-            const newNodeIDs = [];
-            for (const id of newIDs) {
+          const filterIDs = (keep, insert) => {
+            const existingIDs = /* @__PURE__ */ new Set();
+            for (const id of keep) {
               if (!id) {
                 continue;
               }
               const { value: node } = this.storage.get(id, "node");
-              if (typeof node !== "string") {
+              if (!node) {
                 continue;
               }
-              if (!node || !this.storage.get(node, "__typename")) {
+              const nodeID = this.storage.get(node, "id");
+              if (!nodeID) {
                 continue;
               }
-              newNodeIDs.push(node);
+              existingIDs.add(nodeID.value);
             }
-            oldIDs = oldIDs.filter((id) => {
+            return insert.filter((id) => {
               if (!id) {
                 return true;
               }
-              const { value: value2 } = this.storage.get(id, "node");
-              const node = value2;
-              if (newNodeIDs.includes(node) && emptyEdges.includes(node)) {
-                return false;
+              const { value: node } = this.storage.get(id, "node");
+              if (!node) {
+                return true;
+              }
+              const nodeID = this.storage.get(node, "id");
+              if (!nodeID) {
+                return true;
               }
-              return true;
+              return !existingIDs.has(nodeID.value);
             });
-          }
+          };
           for (const update of applyUpdates) {
             if (update !== "replace" && !updates.includes(update)) {
               continue;
             }
             if (update === "prepend") {
-              linkedIDs = newIDs.concat(oldIDs);
+              linkedIDs = newIDs.concat(
+                filterIDs(newIDs, oldIDs)
+              );
               if (layer?.optimistic) {
                 action = () => {
                   for (const id of newIDs) {
@@ -462,7 +469,7 @@ class CacheInternal {
                 };
               }
             } else if (update === "append") {
-              linkedIDs = oldIDs.concat(newIDs);
+              linkedIDs = filterIDs(newIDs, oldIDs).concat(newIDs);
               if (layer?.optimistic) {
                 action = () => {
                   for (const id of newIDs) {

package/build/runtime-esm/client/documentStore.js

@@ -265,9 +265,9 @@ class DocumentStore extends Writable {
         handlers = {
           ...common,
           value,
-          resolve: (ctx2, data) => {
+          resolve: ((ctx2, data) => {
             return common.resolve(ctx2, data ?? value);
-          }
+          })
         };
       } else if (direction === "error") {
         handlers = {

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

@@ -45,7 +45,7 @@ class HoudiniClient {
     }
     this.throwOnError_operations = throwOnError?.operations ?? [];
     let serverPort = globalThis.process?.env?.HOUDINI_PORT ?? "5173";
-    this.url = url ?? (globalThis.window ? "" : `https://localhost:${serverPort}`) + localApiEndpoint(getCurrentConfig());
+    this.url = url ?? (globalThis.window ? "" : `http://localhost:${serverPort}`) + localApiEndpoint(getCurrentConfig());
     this.throwOnError = throwOnError;
     this.fetchParams = fetchParams;
     this.pipeline = pipeline;

package/build/runtime-esm/client/plugins/test.js

@@ -76,7 +76,7 @@ function fakeFetch({
     partial: false,
     stale: false
   };
-  return () => ({
+  return (() => ({
     network(ctx, { resolve }) {
       spy?.(ctx);
       if (onRequest) {
@@ -85,7 +85,7 @@ function fakeFetch({
         resolve(ctx, { ...result });
       }
     }
-  });
+  }));
 }
 export {
   createStore,

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

@@ -372,8 +372,8 @@ export type ProjectManifest = {
     artifacts: string[];
     /** Whether or not there is a local schema defined */
     local_schema: boolean;
-    /** Whether or not there is a custom instance of yoga defined */
-    local_yoga: boolean;
+    /** Whether or not there is a custom server defined */
+    local_server: boolean;
     /** Information about componentFields defined in the project */
     component_fields: Record<string, {
         filepath: string;

package/build/runtime-esm/public/cache.d.ts

@@ -6,7 +6,6 @@ import type { ArgType, CacheTypeDef, IDFields, QueryInput, QueryList, QueryValue
 export declare class Cache<Def extends CacheTypeDef> {
     _internal_unstable: _Cache;
     constructor(cache: _Cache);
-    validateInstabilityWarning(): void;
     get<T extends TypeNames<Def>>(type: T, data: IDFields<Def, T>): Record<Def, T>;
     get config(): import("../lib").ConfigFile;
     list<Name extends ValidLists<Def>>(name: Name, { parentID, allLists }?: {

package/build/runtime-esm/public/cache.js

@@ -6,19 +6,8 @@ class Cache {
   constructor(cache) {
     this._internal_unstable = cache;
   }
-  // if the user is using the imperative API, we want the ability to break the API
-  // with any minor version. In order to do this, we require them to accept this contract
-  // through their config file
-  validateInstabilityWarning() {
-    if (!this.config.acceptImperativeInstability && !this.config.features?.imperativeCache) {
-      console.warn(`\u26A0\uFE0F  The imperative cache API is considered unstable and will change in any minor version release
-Please acknowledge this by enabling the imperative cache feature flage in your config file.
-For more information: https://houdinigraphql.com/api/cache`);
-    }
-  }
   // return the record proxy for the given type/id combo
   get(type, data) {
-    this.validateInstabilityWarning();
     let recordID = this._internal_unstable._internal_unstable.id(type, data);
     if (!recordID) {
       throw new Error("todo");
@@ -34,7 +23,6 @@ For more information: https://houdinigraphql.com/api/cache`);
     return getCurrentConfig();
   }
   list(name, { parentID, allLists } = {}) {
-    this.validateInstabilityWarning();
     return new ListCollection({
       cache: this,
       name,
@@ -46,7 +34,6 @@ For more information: https://houdinigraphql.com/api/cache`);
     query,
     variables
   }) {
-    this.validateInstabilityWarning();
     return this._internal_unstable.read({
       selection: query.artifact.selection,
       variables
@@ -57,7 +44,6 @@ For more information: https://houdinigraphql.com/api/cache`);
     variables,
     data
   }) {
-    this.validateInstabilityWarning();
     this._internal_unstable.write({
       selection: query.artifact.selection,
       // @ts-expect-error

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

@@ -29,13 +29,13 @@ export declare function parse(str: string, options?: {
  *
  */
 export declare function serialize(name: string, val: string, options: {
-    encode: boolean;
-    maxAge: number;
-    domain: string;
-    path: string;
-    expires: Date;
-    httpOnly: boolean;
-    priority: string | number;
-    secure: boolean;
-    sameSite: string | boolean;
+    encode?: boolean;
+    maxAge?: number;
+    domain?: string;
+    path?: string;
+    expires?: Date;
+    httpOnly?: boolean;
+    priority?: string | number;
+    secure?: boolean;
+    sameSite?: string | boolean;
 }): string;

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

@@ -52,7 +52,7 @@ function serialize(name, val, options) {
     throw new TypeError("argument val is invalid");
   }
   let str = name + "=" + value;
-  if (opt.maxAge !== null) {
+  if (opt.maxAge) {
     let maxAge = opt.maxAge - 0;
     if (Number.isNaN(maxAge) || !isFinite(maxAge)) {
       throw new TypeError("option maxAge is invalid");

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

@@ -1,11 +1,11 @@
-import { createServerAdapter as createAdapter } from '@whatwg-node/server';
-import { type GraphQLSchema } from 'graphql';
-import { createYoga } from 'graphql-yoga';
+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, yoga, client, production, manifest, graphqlEndpoint, on_render, componentCache, }: {
+export declare function _serverHandler<ComponentType = unknown>({ schema, server, client, production, manifest, graphqlEndpoint, on_render, componentCache, }: {
     schema?: GraphQLSchema | null;
-    yoga?: ReturnType<typeof createYoga> | null;
+    server?: Server<any, any>;
     client: HoudiniClient;
     production: boolean;
     manifest: RouterManifest<ComponentType> | null;
@@ -20,5 +20,5 @@ export declare function _serverHandler<ComponentType = unknown>({ schema, yoga,
         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 createAdapter>;
+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,14 +1,14 @@
-import { createServerAdapter as createAdapter } from "@whatwg-node/server";
-import { parse, execute } from "graphql";
-import { createYoga } from "graphql-yoga";
-import { localApiSessionKeys, localApiEndpoint, getCurrentConfig } from "../lib/config";
+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 } from "./session";
+import { get_session, handle_request, session_cookie_name } from "./session";
 const config_file = getCurrentConfig();
 const session_keys = localApiSessionKeys(config_file);
 function _serverHandler({
   schema,
-  yoga,
+  server,
   client,
   production,
   manifest,
@@ -16,23 +16,38 @@ function _serverHandler({
   on_render,
   componentCache
 }) {
-  if (schema && !yoga) {
-    yoga = createYoga({
+  if (schema && !server) {
+    server = new Server({
+      landingPage: !production
+    });
+  }
+  let requestHandler = null;
+  if (server && schema) {
+    requestHandler = server.init({
       schema,
-      landingPage: !production,
-      graphqlEndpoint
+      endpoint: graphqlEndpoint,
+      getSession: (request) => get_session(request.headers, session_keys)
     });
   }
   client.componentCache = componentCache;
-  if (schema) {
+  if (requestHandler) {
     client.registerProxy(graphqlEndpoint, async ({ query, variables, session }) => {
-      const parsed = parse(query);
-      return await execute({
-        schema,
-        document: parsed,
-        contextValue: session,
-        variableValues: variables
-      });
+      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) => {
@@ -43,8 +58,8 @@ function _serverHandler({
       );
     }
     const url = new URL(request.url).pathname;
-    if (yoga && url === localApiEndpoint(config_file)) {
-      return yoga(request);
+    if (requestHandler && url === graphqlEndpoint) {
+      return requestHandler(request);
     }
     const authResponse = await handle_request({
       request,
@@ -69,7 +84,7 @@ function _serverHandler({
   };
 }
 const serverAdapterFactory = (args) => {
-  return createAdapter(_serverHandler(args));
+  return createServerAdapter(_serverHandler(args));
 };
 export {
   _serverHandler,

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

@@ -17,5 +17,6 @@ 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

@@ -52,6 +52,9 @@ async function get_session(req, secrets) {
   if (!cookie) {
     return {};
   }
+  if (cookie === "{}") {
+    return {};
+  }
   for (const secret of secrets) {
     if (!await verify(cookie, secret)) {
       continue;
@@ -66,5 +69,6 @@ async function get_session(req, secrets) {
 }
 export {
   get_session,
-  handle_request
+  handle_request,
+  session_cookie_name
 };

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

@@ -0,0 +1,17 @@
+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, 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

@@ -0,0 +1,38 @@
+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
+};