houdini 0.17.4 → 0.17.6

package/src/runtime/cache/subscription.ts

@@ -156,16 +156,17 @@ export class InMemorySubscriptions {
 		selection,
 		variables,
 		subscribers,
+		parentType,
 	}: {
 		parent: string
 		selection: SubscriptionSelection
 		variables: {}
 		subscribers: SubscriptionSpec[]
+		parentType: string
 	}) {
 		// look at every field in the selection and add the subscribers
 		for (const fieldSelection of Object.values(selection)) {
-			const { keyRaw, fields } = fieldSelection
-
+			const { type: linkedType, keyRaw, fields } = fieldSelection
 			const key = evaluateKey(keyRaw, variables)
 
 			// add the subscriber to the
@@ -175,7 +176,7 @@ export class InMemorySubscriptions {
 					key,
 					selection: fieldSelection,
 					spec,
-					parentType: 'asdf',
+					parentType,
 					variables,
 				})
 			}
@@ -183,6 +184,7 @@ export class InMemorySubscriptions {
 			// if there are fields under this
 			if (fields) {
 				const { value: link } = this.cache._internal_unstable.storage.get(parent, key)
+
 				// figure out who else needs subscribers
 				const children = !Array.isArray(link)
 					? ([link] as string[])
@@ -192,13 +194,13 @@ export class InMemorySubscriptions {
 					if (!linkedRecord) {
 						continue
 					}
-
 					// insert the subscriber
 					this.addMany({
 						parent: linkedRecord,
 						selection: fields,
 						variables,
 						subscribers,
+						parentType: linkedType,
 					})
 				}
 			}

package/src/runtime/cache/tests/subscriptions.test.ts

@@ -1,6 +1,7 @@
 import { test, expect, vi } from 'vitest'
 
 import { testConfigFile } from '../../../test'
+import { RefetchUpdateMode, SubscriptionSelection } from '../../lib'
 import { Cache } from '../cache'
 
 const config = testConfigFile()
@@ -1637,6 +1638,120 @@ test('clearing a display layer updates subscribers', function () {
 	})
 })
 
+test('ensure parent type is properly passed for nested lists', function () {
+	// instantiate a cache
+	const cache = new Cache(config)
+
+	const selection: SubscriptionSelection = {
+		cities: {
+			type: 'City',
+			keyRaw: 'cities',
+			list: {
+				name: 'City_List',
+				connection: false,
+				type: 'City',
+			},
+			update: RefetchUpdateMode.append,
+			fields: {
+				id: {
+					type: 'ID',
+					keyRaw: 'id',
+				},
+				name: {
+					type: 'String',
+					keyRaw: 'name',
+				},
+				libraries: {
+					type: 'Library',
+					keyRaw: 'libraries',
+					update: RefetchUpdateMode.append,
+					list: {
+						name: 'Library_List',
+						connection: false,
+						type: 'Library',
+					},
+					fields: {
+						id: {
+							type: 'ID',
+							keyRaw: 'id',
+						},
+						name: {
+							type: 'String',
+							keyRaw: 'name',
+						},
+						books: {
+							type: 'Book',
+							keyRaw: 'books',
+							list: {
+								name: 'Book_List',
+								connection: false,
+								type: 'Book',
+							},
+							fields: {
+								id: {
+									type: 'ID',
+									keyRaw: 'id',
+								},
+								title: {
+									type: 'String',
+									keyRaw: 'title',
+								},
+							},
+						},
+					},
+				},
+			},
+		},
+	}
+
+	// a function to spy on that will play the role of set
+	const set = vi.fn()
+
+	// subscribe to the fields
+	cache.subscribe({
+		rootType: 'Query',
+		selection,
+		set,
+	})
+
+	// add a city to the list by hand since using the list util adds type information
+
+	cache.write({
+		selection,
+		data: {
+			cities: [
+				{
+					id: '1',
+					name: 'Alexandria',
+					libraries: [
+						{
+							id: '1',
+							name: 'The Library of Alexandria',
+							books: [],
+						},
+						{
+							id: '2',
+							name: 'Bibliotheca Alexandrina',
+							books: [],
+						},
+					],
+				},
+				{
+					id: '2',
+					name: 'Aalborg',
+					libraries: [],
+				},
+			],
+		},
+	})
+
+	// since there are multiple lists inside of City_List, we need to
+	// specify the parentID of the city in order to add a library to City:3
+	expect(() => cache.list('Library_List', '2')).not.toThrow()
+	// same with Books_List for Library:2
+	expect(() => cache.list('Book_List', '2')).not.toThrow()
+})
+
 test.todo('can write to and resolve layers')
 
 test.todo("resolving a layer with the same value as the most recent doesn't notify subscribers")

package/src/runtime/lib/network.ts

@@ -2,6 +2,7 @@
 import cache from '../cache'
 import type { ConfigFile } from './config'
 import * as log from './log'
+import { extractFiles } from './networkUtils'
 import {
 	CachePolicy,
 	DataSource,
@@ -22,6 +23,56 @@ export class HoudiniClient {
 		this.socket = subscriptionHandler
 	}
 
+	handleMultipart(
+		params: FetchParams,
+		args: Parameters<FetchContext['fetch']>
+	): Parameters<FetchContext['fetch']> | undefined {
+		// process any files that could be included
+		const { clone, files } = extractFiles({
+			query: params.text,
+			variables: params.variables,
+		})
+
+		// if there are files in the request
+		if (files.size) {
+			const [url, req] = args
+			let headers: Record<string, string> = {}
+
+			// filters `content-type: application/json` if received by client.ts
+			if (req?.headers) {
+				const filtered = Object.entries(req?.headers).filter(([key, value]) => {
+					return !(
+						key.toLowerCase() == 'content-type' &&
+						value.toLowerCase() == 'application/json'
+					)
+				})
+				headers = Object.fromEntries(filtered)
+			}
+
+			// See the GraphQL multipart request spec:
+			// https://github.com/jaydenseric/graphql-multipart-request-spec
+			const form = new FormData()
+			const operationJSON = JSON.stringify(clone)
+
+			form.set('operations', operationJSON)
+
+			const map: Record<string, Array<string>> = {}
+
+			let i = 0
+			files.forEach((paths) => {
+				map[++i] = paths
+			})
+			form.set('map', JSON.stringify(map))
+
+			i = 0
+			files.forEach((paths, file) => {
+				form.set(`${++i}`, file as Blob, (file as File).name)
+			})
+
+			return [url, { ...req, headers, body: form as any }]
+		}
+	}
+
 	async sendRequest<_Data>(
 		ctx: FetchContext,
 		params: FetchParams
@@ -33,7 +84,11 @@ export class HoudiniClient {
 			// wrap the user's fetch function so we can identify SSR by checking
 			// the response.url
 			fetch: async (...args: Parameters<FetchContext['fetch']>) => {
-				const response = await ctx.fetch(...args)
+				// figure out if we need to do something special for multipart uploads
+				const newArgs = this.handleMultipart(params, args)
+
+				// use the new args if they exist, otherwise the old ones are good
+				const response = await ctx.fetch(...(newArgs || args))
 				if (response.url) {
 					url = response.url
 				}
@@ -118,6 +173,7 @@ export async function executeQuery<_Data extends GraphQLObject, _Input extends {
 	artifact,
 	variables,
 	session,
+	setFetching,
 	cached,
 	fetch,
 	metadata,
@@ -126,6 +182,7 @@ export async function executeQuery<_Data extends GraphQLObject, _Input extends {
 	artifact: QueryArtifact | MutationArtifact
 	variables: _Input
 	session: any
+	setFetching: (fetching: boolean) => void
 	cached: boolean
 	config: ConfigFile
 	fetch?: typeof globalThis.fetch
@@ -139,6 +196,7 @@ export async function executeQuery<_Data extends GraphQLObject, _Input extends {
 			session,
 		},
 		artifact,
+		setFetching,
 		variables,
 		cached,
 	})
@@ -156,16 +214,18 @@ export async function executeQuery<_Data extends GraphQLObject, _Input extends {
 
 export async function fetchQuery<_Data extends GraphQLObject, _Input extends {}>({
 	client,
+	context,
 	artifact,
 	variables,
+	setFetching,
 	cached = true,
 	policy,
-	context,
 }: {
 	client: HoudiniClient
 	context: FetchContext
 	artifact: QueryArtifact | MutationArtifact
 	variables: _Input
+	setFetching: (fetching: boolean) => void
 	cached?: boolean
 	policy?: CachePolicy
 }): Promise<FetchQueryResult<_Data>> {
@@ -225,6 +285,9 @@ export async function fetchQuery<_Data extends GraphQLObject, _Input extends {}>
 		cache._internal_unstable.collectGarbage()
 	}, 0)
 
+	// tell everyone that we are fetching if the function is defined
+	setFetching(true)
+
 	// the request must be resolved against the network
 	const result = await client.sendRequest<_Data>(context, {
 		text: artifact.raw,

package/src/runtime/lib/networkUtils.ts

@@ -0,0 +1,151 @@
+/// This file contains a modified version, made by AlecAivazis, of the functions found here: https://github.com/jaydenseric/extract-files/blob/master/extractFiles.mjs
+/// The associated license is at the end of the file (per the project's license agreement)
+
+export function isExtractableFile(value: any): value is ExtractableFile {
+	return (
+		(typeof File !== 'undefined' && value instanceof File) ||
+		(typeof Blob !== 'undefined' && value instanceof Blob)
+	)
+}
+
+type ExtractableFile = File | Blob
+
+/** @typedef {import("./isExtractableFile.mjs").default} isExtractableFile */
+
+export function extractFiles(value: any) {
+	if (!arguments.length) throw new TypeError('Argument 1 `value` is required.')
+
+	/**
+	 * Deeply clonable value.
+	 * @typedef {Array<unknown> | FileList | Record<PropertyKey, unknown>} Cloneable
+	 */
+
+	/**
+	 * Clone of a {@link Cloneable deeply cloneable value}.
+	 * @typedef {Exclude<Cloneable, FileList>} Clone
+	 */
+
+	/**
+	 * Map of values recursed within the input value and their clones, for reusing
+	 * clones of values that are referenced multiple times within the input value.
+	 * @type {Map<Cloneable, Clone>}
+	 */
+	const clones = new Map()
+
+	/**
+	 * Extracted files and their object paths within the input value.
+	 * @type {Extraction<Extractable>["files"]}
+	 */
+	const files = new Map()
+
+	/**
+	 * Recursively clones the value, extracting files.
+	 */
+	function recurse(value: any, path: string | string[], recursed: Set<any>) {
+		if (isExtractableFile(value)) {
+			const filePaths = files.get(value)
+
+			filePaths ? filePaths.push(path) : files.set(value, [path])
+
+			return null
+		}
+
+		const valueIsList =
+			Array.isArray(value) || (typeof FileList !== 'undefined' && value instanceof FileList)
+		const valueIsPlainObject = isPlainObject(value)
+
+		if (valueIsList || valueIsPlainObject) {
+			let clone = clones.get(value)
+
+			const uncloned = !clone
+
+			if (uncloned) {
+				clone = valueIsList
+					? []
+					: // Replicate if the plain object is an `Object` instance.
+					value instanceof /** @type {any} */ Object
+					? {}
+					: Object.create(null)
+
+				clones.set(value, /** @type {Clone} */ clone)
+			}
+
+			if (!recursed.has(value)) {
+				const pathPrefix = path ? `${path}.` : ''
+				const recursedDeeper = new Set(recursed).add(value)
+
+				if (valueIsList) {
+					let index = 0
+
+					// @ts-ignore
+					for (const item of value) {
+						const itemClone = recurse(item, pathPrefix + index++, recursedDeeper)
+
+						if (uncloned) /** @type {Array<unknown>} */ clone.push(itemClone)
+					}
+				} else
+					for (const key in value) {
+						const propertyClone = recurse(value[key], pathPrefix + key, recursedDeeper)
+
+						if (uncloned)
+							/** @type {Record<PropertyKey, unknown>} */ clone[key] = propertyClone
+					}
+			}
+
+			return clone
+		}
+
+		return value
+	}
+
+	return {
+		clone: recurse(value, '', new Set()),
+		files,
+	}
+}
+
+/**
+ * An extraction result.
+ * @template [Extractable=unknown] Extractable file type.
+ * @typedef {object} Extraction
+ * @prop {unknown} clone Clone of the original value with extracted files
+ *   recursively replaced with `null`.
+ * @prop {Map<Extractable, Array<ObjectPath>>} files Extracted files and their
+ *   object paths within the original value.
+ */
+
+/**
+ * String notation for the path to a node in an object tree.
+ * @typedef {string} ObjectPath
+ * @see [`object-path` on npm](https://npm.im/object-path).
+ * @example
+ * An object path for object property `a`, array index `0`, object property `b`:
+ *
+ * ```
+ * a.0.b
+ * ```
+ */
+
+function isPlainObject(value: any) {
+	if (typeof value !== 'object' || value === null) {
+		return false
+	}
+
+	const prototype = Object.getPrototypeOf(value)
+	return (
+		(prototype === null ||
+			prototype === Object.prototype ||
+			Object.getPrototypeOf(prototype) === null) &&
+		!(Symbol.toStringTag in value) &&
+		!(Symbol.iterator in value)
+	)
+}
+
+// MIT License
+// Copyright Jayden Seric
+
+// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+// The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.