houdini-core 2.0.0-go.0

package/runtime/plugins/throwOnError.ts

@@ -0,0 +1,44 @@
+import type { ClientPlugin, ClientPluginContext } from 'houdini/runtime/documentStore'
+import type { ArtifactKinds, QueryResult } from 'houdini/runtime/types'
+import { ArtifactKind } from 'houdini/runtime/types'
+
+export type ThrowOnErrorOperations = 'all' | 'query' | 'mutation' | 'subscription'
+
+export type ThrowOnErrorParams = {
+	operations: ThrowOnErrorOperations[]
+	error?: (
+		errors: NonNullable<QueryResult<any, any>['errors']>,
+		ctx: ClientPluginContext
+	) => unknown
+}
+
+export const throwOnError =
+	({ operations, error }: ThrowOnErrorParams): ClientPlugin =>
+	() => {
+		// build a map of artifact kinds we will throw on
+		const all = operations.includes('all')
+		const throwOnKind = (kind: ArtifactKinds) =>
+			all ||
+			{
+				[ArtifactKind.Query]: operations.includes('query'),
+				[ArtifactKind.Mutation]: operations.includes('mutation'),
+				[ArtifactKind.Fragment]: false,
+				[ArtifactKind.Subscription]: operations.includes('subscription'),
+			}[kind]
+
+		return {
+			async end(ctx, { value, resolve }) {
+				// if we are supposed to throw and there are errors
+				if (value.errors && value.errors.length > 0 && throwOnKind(ctx.artifact.kind)) {
+					const result = await (error ?? defaultErrorFn)(value.errors, ctx)
+					throw result
+				}
+
+				// we're not supposed to throw, move on
+				resolve(ctx)
+			},
+		}
+	}
+
+const defaultErrorFn: Required<ThrowOnErrorParams>['error'] = async (errors) =>
+	new Error(errors.map((error) => error.message).join('. ') + '.')

package/runtime/plugins/utils/documentPlugins.ts

@@ -0,0 +1,54 @@
+import type { ArtifactKinds } from 'houdini/runtime'
+import type {
+	ClientPlugin,
+	ClientPluginExitPhase,
+	ClientPluginEnterPhase,
+	ClientHooks,
+} from 'houdini/runtime/documentStore'
+
+export const documentPlugin = (kind: ArtifactKinds, source: () => ClientHooks): ClientPlugin => {
+	return () => {
+		// pull out the hooks we care about
+		const sourceHandlers = source()
+
+		const enterWrapper = (
+			handler?: ClientPluginEnterPhase
+		): ClientPluginEnterPhase | undefined => {
+			return !handler
+				? undefined
+				: (ctx, handlers) => {
+						if (ctx.artifact.kind !== kind) {
+							return handlers.next(ctx)
+						}
+
+						return handler(ctx, handlers)
+				  }
+		}
+		const exitWrapper = (
+			handler?: ClientPluginExitPhase
+		): ClientPluginExitPhase | undefined => {
+			return !handler
+				? undefined
+				: (ctx, handlers) => {
+						if (ctx.artifact.kind !== kind) {
+							return handlers.resolve(ctx)
+						}
+
+						return handler(ctx, handlers)
+				  }
+		}
+
+		// return the modified hooks
+		return {
+			start: enterWrapper(sourceHandlers.start),
+			network: enterWrapper(sourceHandlers.network),
+			beforeNetwork: enterWrapper(sourceHandlers.beforeNetwork),
+			afterNetwork: exitWrapper(sourceHandlers.afterNetwork),
+			end: exitWrapper(sourceHandlers.end),
+			catch: sourceHandlers.catch
+				? (ctx, handlers) => sourceHandlers.catch!(ctx, handlers)
+				: undefined,
+			cleanup: (...args) => sourceHandlers.cleanup?.(...args),
+		}
+	}
+}

package/runtime/plugins/utils/index.ts

@@ -0,0 +1 @@
+export * from './documentPlugins'

package/runtime/public/cache.ts

@@ -0,0 +1,121 @@
+import type { Cache as _Cache } from 'houdini/runtime/cache'
+import { marshalInputs } from 'houdini/runtime/scalars'
+import type { QueryArtifact } from 'houdini/runtime/types'
+
+import { getCurrentConfig } from '../config'
+import { ListCollection } from './list'
+import { Record } from './record'
+import type {
+	ArgType,
+	CacheTypeDef,
+	IDFields,
+	QueryInput,
+	QueryList,
+	QueryValue,
+	TypeFieldNames,
+	TypeNames,
+	ValidLists,
+} from './types'
+
+export class Cache<Def extends CacheTypeDef> {
+	_internal_unstable: _Cache
+
+	constructor(cache: _Cache) {
+		this._internal_unstable = cache
+	}
+
+	// return the record proxy for the given type/id combo
+	get<T extends TypeNames<Def>>(type: T, data: IDFields<Def, T>): Record<Def, T> {
+		// compute the id for the record
+		let recordID = this._internal_unstable._internal_unstable.id(type, data)
+		if (!recordID) {
+			throw new Error('todo')
+		}
+
+		// return the proxy
+		return new Record({
+			cache: this,
+			type: type,
+			id: recordID,
+			idFields: data,
+		})
+	}
+
+	get config() {
+		return getCurrentConfig()
+	}
+
+	list<Name extends ValidLists<Def>>(
+		name: Name,
+		{ parentID, allLists }: { parentID?: string; allLists?: boolean } = {}
+	): ListCollection<Def, Name> {
+		return new ListCollection<Def, Name>({
+			cache: this,
+			name,
+			parentID,
+			allLists,
+		})
+	}
+
+	read<_Query extends { artifact: QueryArtifact }>({
+		query,
+		variables,
+	}: {
+		query: _Query
+		variables?: QueryInput<QueryList<Def>, _Query>
+	}): {
+		data: QueryValue<QueryList<Def>, _Query> | null
+		partial: boolean
+	} {
+		// @ts-expect-error
+		return this._internal_unstable.read({
+			selection: query.artifact.selection,
+			variables,
+		})
+	}
+
+	write<_Query extends { artifact: QueryArtifact }>({
+		query,
+		variables,
+		data,
+	}: {
+		query: _Query
+		data: QueryValue<QueryList<Def>, _Query>
+		variables?: QueryInput<QueryList<Def>, _Query>
+	}) {
+		this._internal_unstable.write({
+			selection: query.artifact.selection,
+			// @ts-expect-error
+			data,
+			variables:
+				marshalInputs({
+					config: this.config,
+					artifact: query.artifact,
+					input: variables,
+				}) ?? {},
+		})
+
+		return
+	}
+
+	/**
+	 * Mark some elements of the cache stale.
+	 */
+	markStale<_Type extends TypeNames<Def>, _Field extends TypeFieldNames<Def, _Type>>(
+		type?: _Type,
+		options?: {
+			field?: _Field
+			when?: ArgType<Def, _Type, _Field>
+		}
+	): void {
+		return this._internal_unstable.markTypeStale(type ? { ...options, type } : undefined)
+	}
+
+	/**
+	 * Reset the entire cache by clearing all records and lists
+	 */
+
+	reset(): void {
+		return this._internal_unstable.reset()
+	}
+}

package/runtime/public/index.ts

@@ -0,0 +1 @@
+export { Cache } from './cache'

package/runtime/public/list.ts

@@ -0,0 +1,164 @@
+import type { GraphQLObject, SubscriptionSelection } from 'houdini/runtime'
+import type { ListCollection as _Collection } from 'houdini/runtime/cache/lists'
+
+import type { Cache } from './cache'
+import { Record } from './record'
+import type { CacheTypeDef, ListType, ValidLists, ListFilters } from './types'
+
+export class ListCollection<Def extends CacheTypeDef, ListName extends ValidLists<Def>> {
+	#parentID: string | undefined
+	#allLists: boolean | undefined
+	#when: ListFilters<Def, ListName> | undefined
+	#cache: Cache<Def>
+	#name: ValidLists<Def>
+
+	constructor({
+		parentID,
+		allLists,
+		when,
+		cache,
+		name,
+	}: {
+		name: ValidLists<Def>
+		parentID?: string
+		allLists?: boolean
+		when?: ListFilters<Def, ListName>
+		cache: Cache<Def>
+	}) {
+		this.#parentID = parentID
+		this.#allLists = allLists
+		this.#when = when
+		this.#cache = cache
+		this.#name = name
+	}
+
+	append(...records: ListType<Def, ListName>[]) {
+		if (!this.#collection) {
+			return
+		}
+
+		const { selection, data } = this.#listOperationPayload(records)
+		for (const entry of data) {
+			if (entry) {
+				this.#collection.append({
+					selection,
+					data: entry,
+				})
+			}
+		}
+	}
+
+	prepend(...records: ListType<Def, ListName>[]) {
+		if (!this.#collection) {
+			return
+		}
+
+		const { selection, data } = this.#listOperationPayload(records)
+		for (const entry of data) {
+			if (entry) {
+				this.#collection.prepend({
+					selection,
+					data: entry,
+				})
+			}
+		}
+	}
+
+	toggle(where: 'first' | 'last', ...records: ListType<Def, ListName>[]) {
+		if (!this.#collection) {
+			return
+		}
+
+		const { selection, data } = this.#listOperationPayload(records)
+		for (const entry of data) {
+			if (entry) {
+				this.#collection.toggleElement({
+					selection,
+					data: entry,
+					where,
+				})
+			}
+		}
+	}
+
+	when(filter: ListFilters<Def, ListName>): ListCollection<Def, ListName> {
+		if (!this.#collection) {
+			return this
+		}
+
+		return new ListCollection({
+			parentID: this.#parentID,
+			allLists: this.#allLists,
+			when: filter,
+			cache: this.#cache,
+			name: this.#name,
+		})
+	}
+
+	remove(...records: ListType<Def, ListName>[]) {
+		if (!this.#collection) {
+			return
+		}
+
+		for (const record of records) {
+			if (record) {
+				this.#collection.remove(record.idFields)
+			}
+		}
+	}
+
+	*[Symbol.iterator]() {
+		for (const entry of this.#collection ?? []) {
+			yield entry
+		}
+	}
+
+	get #collection(): _Collection | null {
+		try {
+			const list = this.#cache._internal_unstable.list(
+				this.#name,
+				this.#parentID,
+				this.#allLists
+			)
+			if (this.#when) {
+				return list.when(this.#when)
+			}
+			return list
+		} catch {
+			return null
+		}
+	}
+
+	#listOperationPayload(records: ListType<Def, ListName>[]): {
+		selection: SubscriptionSelection
+		data: GraphQLObject[]
+	} {
+		// we need to build up the selection that describes the key
+		// for every type in the list
+		let selection: SubscriptionSelection = this.#collection!.selection
+		// if the list is a connection, we can't use this selection immediately
+		// we need to look for edges.node
+		const connectionSelection = selection.fields?.['edges']?.selection?.fields?.node.selection
+		if (connectionSelection) {
+			selection = connectionSelection
+		}
+
+		// and the actual data for the record
+		const data: GraphQLObject[] = []
+
+		// loop over every record we are adding to build up the necessary structure
+		for (const record of records) {
+			if (!(record instanceof Record)) {
+				throw new Error('You must provide a Record to a list operation')
+			}
+
+			// add the necessary information
+			data.push({ __typename: record.type, ...record.idFields })
+		}
+
+		return {
+			selection,
+			data,
+		}
+	}
+}

package/runtime/public/record.ts

@@ -0,0 +1,113 @@
+import { marshalInputs } from 'houdini/runtime'
+import { keyFieldsForType } from 'houdini/runtime'
+import type { FragmentArtifact, GraphQLObject } from 'houdini/runtime'
+import { rootID } from 'houdini/runtime/cache/stuff'
+
+import type { Cache } from './cache'
+import type {
+	ArgType,
+	CacheTypeDef,
+	FragmentList,
+	FragmentValue,
+	FragmentVariables,
+	TypeFieldNames,
+	ValidTypes,
+} from './types'
+
+export class Record<Def extends CacheTypeDef, Type extends ValidTypes<Def>> {
+	#id: string
+	#cache: Cache<Def>
+
+	type: string
+	idFields: {}
+
+	constructor({
+		cache,
+		type,
+		id,
+		idFields,
+	}: {
+		cache: Cache<Def>
+		type: string
+		idFields: {}
+		id: string
+	}) {
+		this.#cache = cache
+		this.#id = id
+		this.type = type
+		this.idFields = idFields
+
+		// make sure that we have all of the necessary fields for the id
+		if (id !== rootID) {
+			for (const key of keyFieldsForType(this.#cache.config, type)) {
+				if (!(key in idFields)) {
+					throw new Error('Missing key in idFields: ' + key)
+				}
+			}
+		}
+	}
+
+	read<_Fragment extends { artifact: FragmentArtifact }>({
+		fragment,
+		variables,
+	}: {
+		fragment: _Fragment
+		variables?: FragmentVariables<FragmentList<Def, Type>, _Fragment>
+	}): { data: FragmentValue<FragmentList<Def, Type>, _Fragment> | null; partial: boolean } {
+		// @ts-expect-error
+		return this.#cache._internal_unstable.read({
+			selection: fragment.artifact.selection,
+			parent: this.#id,
+			variables:
+				marshalInputs({
+					config: this.#cache.config,
+					artifact: fragment.artifact,
+					input: variables,
+				}) ?? undefined,
+		})
+	}
+
+	write<_Fragment extends { artifact: FragmentArtifact }, _Variable>(args: {
+		fragment: _Fragment
+		data: FragmentValue<FragmentList<Def, Type>, _Fragment>
+		// TODO: figure out a way to make this required  when _Variables has a value
+		//       and optional when _Variables is never
+		variables?: FragmentVariables<FragmentList<Def, Type>, _Fragment>
+		forceStale?: boolean
+	}) {
+		// we have the data and the fragment, just pass them both to the cache
+		this.#cache._internal_unstable.write({
+			data: args.data as unknown as GraphQLObject,
+			selection: args.fragment.artifact.selection,
+			parent: this.#id,
+			variables:
+				marshalInputs({
+					config: this.#cache.config,
+					artifact: args.fragment.artifact,
+					input: args.variables,
+				}) ?? undefined,
+			forceStale: args.forceStale,
+		})
+	}
+
+	delete() {
+		this.#cache._internal_unstable.delete(this.#id)
+	}
+
+	/**
+	 * Mark some elements of the record stale in the cache.
+	 * @param field
+	 * @param when
+	 */
+	markStale<Field extends TypeFieldNames<Def, Type>>(
+		field?: Field,
+		{
+			when,
+		}: {
+			when?: ArgType<Def, Type, Field>
+		} = {}
+	): void {
+		// mark the record
+		this.#cache._internal_unstable.markRecordStale(this.#id, { field, when })
+	}
+}

package/runtime/public/types.ts

@@ -0,0 +1,166 @@
+import type { Record } from './record'
+
+export type CacheTypeDef = {
+	types: {
+		[typeName: string]: {
+			idFields: {
+				[fieldName: string]: any
+			}
+			fields: {
+				[fieldName: string]: {
+					args: any
+					type: any
+				}
+			}
+			// the fragments we know about are passed as a list of pairs
+			// that map the tag return type to the data shape and input
+			fragments: [any, any, any][]
+		}
+	}
+	lists: {
+		[listName: string]: {
+			types: any
+			filters: any
+		}
+	}
+	// we need to map query tag values to their result
+	// to pass be able to pass queries to the read and write methods
+	// entries in the tuple are graphql tag, query shape, query input
+	queries: [any, any, any][]
+
+	// a union of valid runtime types (default scalars | config types)
+	scalars: any
+}
+
+export type ValidTypes<Def extends CacheTypeDef> = keyof Def['types']
+
+export type TypeFields<
+	Def extends CacheTypeDef,
+	Type extends keyof Def['types']
+> = Def['types'][Type]['fields']
+
+export type TypeFieldNames<
+	Def extends CacheTypeDef,
+	Type extends keyof Def['types']
+	// Extract is necessary because javascript allows numbers to be used as strings when indexing objects
+	// for more information: https://stackoverflow.com/questions/51808160/keyof-inferring-string-number-when-key-is-only-a-string
+> = Extract<keyof TypeFields<Def, Type>, string>
+
+export type TypeNames<Def extends CacheTypeDef> = Extract<
+	Exclude<ValidTypes<Def>, '__ROOT__'>,
+	string
+>
+
+export type FragmentList<
+	Def extends CacheTypeDef,
+	Type extends ValidTypes<Def>
+> = Def['types'][Type]['fragments']
+
+export type QueryList<Def extends CacheTypeDef> = Def['queries']
+
+export type IDFields<
+	Def extends CacheTypeDef,
+	Type extends keyof Def['types']
+> = Def['types'][Type]['idFields']
+
+export type ProxyUnion<Def extends CacheTypeDef, U> = U extends null
+	? null
+	: U extends TypeNames<Def>
+	? Record<Def, U>
+	: never
+
+export type FieldType<
+	Def extends CacheTypeDef,
+	Type extends keyof Def['types'],
+	Field extends keyof TypeFields<Def, Type>
+> = TypeFields<Def, Type>[Field]['type']
+
+export type ArgType<
+	Def extends CacheTypeDef,
+	Type extends keyof Def['types'],
+	Field extends keyof TypeFields<Def, Type>
+> = TypeFields<Def, Type>[Field]['args']
+
+export type ValidLists<Def extends CacheTypeDef> = Extract<keyof Def['lists'], string>
+
+export type ListFilters<
+	Def extends CacheTypeDef,
+	ListName extends ValidLists<Def>
+> = Def['lists'][ListName]['filters'] extends any
+	? {
+			must?: Def['lists'][ListName]['filters']
+			must_not?: Def['lists'][ListName]['filters']
+	  }
+	: never
+
+export type ListType<Def extends CacheTypeDef, Name extends ValidLists<Def>> = ProxyUnion<
+	Def,
+	Def['lists'][Name]['types']
+>
+
+// This same structure is repeated because when I dry'd the structure to
+//
+// type FragmentDefinition<_List, _Index, _Target>
+// type FragmentVariables<_Def, _Type, _Target> = FragmentDefinition<FragmentList<...>>
+//
+// then typescript wasn't responding on every change... Having the duplication makes
+// it very responsive.
+
+/**
+ * Note on the `_Key extends _Target && _Target extends _Key` check:
+ * Sometimes two queries might have a similar shape/inputs, e.g.:
+ *
+ * query Query1($userId: ID!) {    |    query Query2($userId: ID!) {
+ *   user(id: $userId) {           |      user($id: $userId) {
+ *     id                          |        id
+ *     name                        |        name
+ *   }                             |        birthDate
+ * }                               |      }
+ *                                 |    }
+ *
+ * To TypeScript, it would look like Query2's result would extend Query1's result.
+ * But if Query2 was listed in front of Query1 in the queries array above, `_Key extends _Target` will evaluate to true,
+ * causing it to return Query2's input/result types, while you were looking for Query1's input/result types.
+ * The additional `_Target extends _Key` ensures that the two objects have exactly the same shape, at least prompting the
+ * user for the correct fields.
+ */
+
+export type FragmentVariables<_List, _Target> = _List extends [infer Head, ...infer Rest]
+	? Head extends [infer _Key, infer _Value, infer _Input]
+		? _Key extends _Target
+			? _Target extends _Key
+				? _Input
+				: FragmentValue<Rest, _Target>
+			: FragmentValue<Rest, _Target>
+		: 'Encountered unknown fragment. Please make sure your runtime is up to date (ie, `vite dev` or `vite build`).'
+	: 'Encountered unknown fragment. Please make sure your runtime is up to date (ie, `vite dev` or `vite build`).'
+
+export type FragmentValue<List, _Target> = List extends [infer Head, ...infer Rest]
+	? Head extends [infer _Key, infer _Value, infer _Input]
+		? _Key extends _Target
+			? _Target extends _Key
+				? _Value
+				: FragmentValue<Rest, _Target>
+			: FragmentValue<Rest, _Target>
+		: 'Encountered unknown fragment. Please make sure your runtime is up to date (ie, `vite dev` or `vite build`).'
+	: 'Encountered unknown fragment. Please make sure your runtime is up to date (ie, `vite dev` or `vite build`).'
+
+export type QueryValue<List, _Target> = List extends [infer Head, ...infer Rest]
+	? Head extends [infer _Key, infer _Value, infer _Input]
+		? _Key extends _Target
+			? _Target extends _Key
+				? _Value
+				: QueryValue<Rest, _Target>
+			: QueryValue<Rest, _Target>
+		: 'Encountered unknown query.Please make sure your runtime is up to date (ie, `vite dev` or `vite build`).'
+	: 'Encountered unknown query.Please make sure your runtime is up to date (ie, `vite dev` or `vite build`).'
+
+export type QueryInput<List, _Target> = List extends [infer Head, ...infer Rest]
+	? Head extends [infer _Key, infer _Value, infer _Input]
+		? _Key extends _Target
+			? _Target extends _Key
+				? _Input
+				: QueryInput<Rest, _Target>
+			: QueryInput<Rest, _Target>
+		: 'Encountered unknown query.Please make sure your runtime is up to date (ie, `vite dev` or `vite build`).'
+	: 'Encountered unknown query.Please make sure your runtime is up to date (ie, `vite dev` or `vite build`).'

package/runtime/server/index.ts

@@ -0,0 +1 @@
+export { Server } from 'houdini/router/server'