houdini 0.17.8 → 0.17.10

package/src/codegen/transforms/schema.test.ts

@@ -1,136 +0,0 @@
-import { describe, test } from 'vitest'
-
-import { pipelineTest, testConfig } from '../../test'
-
-describe('schema transform', function () {
-	// we'll test the schema additions by pushing some documents through
-	// and make sure they don't error
-	const table = [
-		{
-			title: 'list directive',
-			documents: [
-				`
-					fragment Foo on User {
-
-						friends @list(name:"Friends") {
-							id
-						}
-					}
-				`,
-			],
-			pass: true,
-		},
-		{
-			title: 'prepend directive',
-			documents: [
-				`
-					mutation Update {
-						updateUser {
-							...A @prepend
-						}
-					}
-				`,
-				`
-					fragment A on User {
-						id
-					}
-				`,
-			],
-			pass: true,
-		},
-		{
-			title: 'append directive',
-			documents: [
-				`
-					mutation Update {
-						updateUser {
-							...A @prepend
-						}
-					}
-				`,
-				`
-					fragment A on User {
-						id
-					}
-				`,
-			],
-			pass: true,
-		},
-		{
-			title: 'prepend directive - when arg',
-			documents: [
-				`
-					mutation Update {
-						updateUser {
-							...A @prepend(when: { value: "value" })
-						}
-					}
-				`,
-				`
-					fragment A on User {
-						id
-					}
-				`,
-			],
-			pass: true,
-		},
-		{
-			title: 'when directive',
-			documents: [
-				`
-					mutation Update {
-						updateUser {
-							...A @when(argument: "value", value: "value")
-						}
-					}
-				`,
-				`
-					fragment A on User {
-						id
-					}
-				`,
-			],
-			pass: true,
-		},
-		{
-			title: 'when_not directive',
-			documents: [
-				`
-					mutation Update {
-						updateUser {
-							...A @when_not(argument: "value", value: "value")
-						}
-					}
-				`,
-				`
-					fragment A on User {
-						id
-					}
-				`,
-			],
-			pass: true,
-		},
-		{
-			title: 'append directive - when arg',
-			documents: [
-				`
-					mutation Update {
-						updateUser {
-							...A @append(when: { value: "value" })
-						}
-					}
-				`,
-				`
-					fragment A on User {
-						id
-					}
-				`,
-			],
-			pass: true,
-		},
-	]
-
-	for (const row of table) {
-		test(row.title, pipelineTest(testConfig(), row.documents, row.pass))
-	}
-})

package/src/codegen/transforms/schema.ts

@@ -1,104 +0,0 @@
-import * as graphql from 'graphql'
-
-import { Config, CollectedGraphQLDocument, siteURL } from '../../lib'
-import { CachePolicy } from '../../runtime/lib/types'
-
-// graphqlExtensions adds a few different things to the graphql schema
-export default async function graphqlExtensions(
-	config: Config,
-	documents: CollectedGraphQLDocument[]
-): Promise<void> {
-	// the bits to add to the schema
-	const internalSchema = `
-enum CachePolicy {
-	${CachePolicy.CacheAndNetwork}
-	${CachePolicy.CacheOnly}
-	${CachePolicy.CacheOrNetwork}
-	${CachePolicy.NetworkOnly}
-}
-
-"""
-	@${config.listDirective} is used to mark a field for the runtime as a place to add or remove
-	entities in mutations
-"""
-directive @${config.listDirective}(${config.listNameArg}: String!, connection: Boolean) on FIELD
-
-"""
-	@${config.paginateDirective} is used to to mark a field for pagination.
-	More info in the [doc](${siteURL}/guides/pagination).
-"""
-directive @${config.paginateDirective}(${config.paginateNameArg}: String) on FIELD
-
-"""
-	@${config.listPrependDirective} is used to tell the runtime to add the result to the end of the list
-"""
-directive @${config.listPrependDirective}(
-	${config.listDirectiveParentIDArg}: ID
-) on FRAGMENT_SPREAD
-
-"""
-	@${
-		config.listAppendDirective
-	} is used to tell the runtime to add the result to the start of the list
-"""
-directive @${config.listAppendDirective}(${config.listDirectiveParentIDArg}: ID) on FRAGMENT_SPREAD
-
-"""
-	@${
-		config.listParentDirective
-	} is used to provide a parentID without specifying position or in situations
-	where it doesn't make sense (eg when deleting a node.)
-"""
-directive @${config.listParentDirective}(value: ID!) on FRAGMENT_SPREAD
-
-"""
-	@${
-		config.whenDirective
-	} is used to provide a conditional or in situations where it doesn't make sense (eg when removing or deleting a node.)
-"""
-directive @${config.whenDirective} on FRAGMENT_SPREAD
-
-"""
-	@${
-		config.whenNotDirective
-	} is used to provide a conditional or in situations where it doesn't make sense (eg when removing or deleting a node.)
-"""
-directive @${config.whenNotDirective} on FRAGMENT_SPREAD
-
-"""
-	@${config.argumentsDirective} is used to define the arguments of a fragment
-"""
-directive @${config.argumentsDirective} on FRAGMENT_DEFINITION
-
-"""
-	@${config.cacheDirective} is used to specify cache rules for a query
-"""
-directive @${config.cacheDirective}(${config.cachePolicyArg}: CachePolicy, ${
-		config.cachePartialArg
-	}: Boolean) on QUERY
-
-"""
-	@${config.houdiniDirective} is used to configure houdini's internal behavior
-"""
-directive @${config.houdiniDirective}(
-	"""
-	Opt-in to an automatic load function (only valid when used at queries)
-	"""
-	load: Boolean! = true
-	"""
-	Mask fragment fields (only valid when used at a fragment spread)
-	"""
-	mask: Boolean! = ${config.disableMasking ? 'false' : 'true'}
-) on QUERY | FRAGMENT_SPREAD
-`
-
-	// if the config does not have the cache directive, then we need to add it
-	let currentSchema = graphql.printSchema(config.schema)
-	if (!currentSchema.includes(`directive @${config.listDirective}`)) {
-		currentSchema += internalSchema
-	}
-
-	config.newSchema += internalSchema
-	// add the static extra bits that will be used by other transforms
-	config.schema = graphql.buildSchema(currentSchema)
-}

package/src/codegen/transforms/typename.test.ts

@@ -1,125 +0,0 @@
-import { test, expect } from 'vitest'
-
-import { runPipeline } from '../../codegen'
-import { mockCollectedDoc, testConfig } from '../../test'
-
-test('adds __typename on interface selection sets under query', async function () {
-	const docs = [
-		mockCollectedDoc(
-			`
-				query Friends {
-					friends {
-                        ... on Cat { 
-                            id
-                        }
-                        ... on Ghost { 
-                            name
-                        }
-					}
-				}
-			`
-		),
-	]
-
-	// run the pipeline
-	const config = testConfig()
-	await runPipeline(config, docs)
-
-	expect(docs[0].document).toMatchInlineSnapshot(`
-		query Friends {
-		  friends {
-		    ... on Cat {
-		      id
-		    }
-		    ... on Ghost {
-		      name
-		    }
-		    __typename
-		  }
-		}
-
-	`)
-})
-
-test('adds __typename on interface selection sets under an object', async function () {
-	const docs = [
-		mockCollectedDoc(
-			`
-				query Friends {
-                    users(stringValue: "hello") { 
-                        friendsInterface {
-                            ... on Cat { 
-                                id
-                            }
-                            ... on Ghost { 
-                                name
-                                aka
-                            }
-                        }
-                    }
-				}
-			`
-		),
-	]
-
-	// run the pipeline
-	const config = testConfig()
-	await runPipeline(config, docs)
-
-	expect(docs[0].document).toMatchInlineSnapshot(`
-		query Friends {
-		  users(stringValue: "hello") {
-		    friendsInterface {
-		      ... on Cat {
-		        id
-		      }
-		      ... on Ghost {
-		        name
-		        aka
-		      }
-		      __typename
-		    }
-		    id
-		  }
-		}
-
-	`)
-})
-
-test('adds __typename on unions', async function () {
-	const docs = [
-		mockCollectedDoc(
-			`
-				query Friends {
-					entities {
-                        ... on Cat { 
-                            id
-                        }
-                        ... on Ghost { 
-                            name
-                        }
-					}
-				}
-			`
-		),
-	]
-
-	// run the pipeline
-	const config = testConfig()
-	await runPipeline(config, docs)
-
-	expect(docs[0].document).toMatchInlineSnapshot(`
-		query Friends {
-		  entities {
-		    ... on Cat {
-		      id
-		    }
-		    ... on Ghost {
-		      name
-		    }
-		    __typename
-		  }
-		}
-
-	`)
-})

package/src/codegen/transforms/typename.ts

@@ -1,55 +0,0 @@
-import * as graphql from 'graphql'
-
-import { Config, parentTypeFromAncestors, CollectedGraphQLDocument } from '../../lib'
-import { unwrapType } from '../utils'
-
-// typename adds __typename to the selection set of any unions or interfaces
-export default async function addTypename(
-	config: Config,
-	documents: CollectedGraphQLDocument[]
-): Promise<void> {
-	// visit every document
-	for (const doc of documents) {
-		// update the document (graphql.visit is pure)
-		doc.document = graphql.visit(doc.document, {
-			Field(node, key, parent, path, ancestors): graphql.ASTNode | undefined {
-				// if we are looking at a leaf type
-				if (!node.selectionSet) {
-					return
-				}
-
-				// figure out the parent type
-				const type = parentTypeFromAncestors(
-					config.schema,
-					doc.filename,
-					ancestors.slice(0, -1)
-				)
-				// look up the field definition in the parent type
-				const field = type.getFields()[node.name.value]
-
-				// look up the field in the parent
-				const fieldType = unwrapType(config, field.type).type
-				// if we are looking at an interface
-				if (graphql.isInterfaceType(fieldType) || graphql.isUnionType(fieldType)) {
-					// add the __typename selection to the field's selection set
-					return {
-						...node,
-						selectionSet: {
-							...node.selectionSet,
-							selections: [
-								...node.selectionSet.selections,
-								{
-									kind: graphql.Kind.FIELD,
-									name: {
-										kind: graphql.Kind.NAME,
-										value: '__typename',
-									},
-								},
-							],
-						},
-					}
-				}
-			},
-		})
-	}
-}

package/src/codegen/utils/commonjs.ts

@@ -1,26 +0,0 @@
-// this file exports a few functions that can be used to help generate
-// commonjs files
-export const cjsIndexFilePreamble = `"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });`
-
-export function exportStarFrom(where: string): string {
-	return `__exportStar(require("${where}"), exports);`
-}
-
-export function exportDefaultFrom(where: string, as: string): string {
-	return `var ${as} = require("${where}");
-Object.defineProperty(exports, "${as}", { enumerable: true, get: function () { return __importDefault(${as}).default; } });`
-}

package/src/codegen/utils/flattenSelections.ts

@@ -1,179 +0,0 @@
-import * as graphql from 'graphql'
-
-import { Config, HoudiniError } from '../../lib'
-
-export function flattenSelections({
-	config,
-	filepath,
-	selections,
-	fragmentDefinitions,
-}: {
-	config: Config
-	filepath: string
-	selections: readonly graphql.SelectionNode[]
-	fragmentDefinitions: { [name: string]: graphql.FragmentDefinitionNode }
-}): readonly graphql.SelectionNode[] {
-	// collect all of the fields together
-	const fields = new FieldCollection({
-		config,
-		filepath,
-		selections,
-		fragmentDefinitions,
-	})
-
-	// convert the flat fields into a selection set
-	return fields.toSelectionSet()
-}
-
-class FieldCollection {
-	config: Config
-	fragmentDefinitions: { [name: string]: graphql.FragmentDefinitionNode }
-	filepath: string
-
-	fields: { [name: string]: Field<graphql.FieldNode> }
-	inlineFragments: { [typeName: string]: Field<graphql.InlineFragmentNode> }
-	fragmentSpreads: { [fragmentName: string]: graphql.FragmentSpreadNode }
-
-	constructor(args: {
-		config: Config
-		filepath: string
-		selections: readonly graphql.SelectionNode[]
-		fragmentDefinitions: { [name: string]: graphql.FragmentDefinitionNode }
-	}) {
-		this.config = args.config
-		this.fragmentDefinitions = args.fragmentDefinitions
-
-		this.fields = {}
-		this.inlineFragments = {}
-		this.fragmentSpreads = {}
-
-		this.filepath = args.filepath
-
-		for (const selection of args.selections) {
-			this.add(selection)
-		}
-	}
-
-	add(selection: graphql.SelectionNode) {
-		// how we handle the field depends on what kind of field it is
-		if (selection.kind === 'Field') {
-			// figure out the key of the field
-			const key = selection.alias?.value || selection.name.value
-
-			// if we don't already have a field with that name
-			if (!this.fields[key]) {
-				// create an entry for the selection field
-				this.fields[key] = {
-					astNode: selection,
-					selection: this.empty(),
-				}
-			}
-
-			// its safe to all this fields selections if they exist
-			for (const subselect of selection.selectionSet?.selections || []) {
-				this.fields[key].selection.add(subselect)
-			}
-
-			// we're done
-			return
-		}
-
-		// we could run into an inline fragment that doesn't assert a type (treat it as a field selection)
-		if (selection.kind === 'InlineFragment' && !selection.typeCondition) {
-			for (const subselect of selection.selectionSet.selections) {
-				this.add(subselect)
-			}
-		}
-
-		// we could run into an inline fragment. the application has been validated already
-		// so we just need to add it to the inline fragment for the appropriate type
-		if (selection.kind === 'InlineFragment' && selection.typeCondition) {
-			// figure out the key of the field
-			const key = selection.typeCondition.name.value
-
-			// if we don't already have an inline fragment of that type
-			if (!this.inlineFragments[key]) {
-				// create an entry for the selection field
-				this.inlineFragments[key] = {
-					astNode: selection,
-					selection: this.empty(),
-				}
-			}
-
-			// its safe to all this fields selections if they exist
-			for (const subselect of selection.selectionSet?.selections || []) {
-				this.inlineFragments[key].selection.add(subselect)
-			}
-
-			// we're done
-			return
-		}
-
-		// the only thing that's left is external fragment spreads
-		if (selection.kind === 'FragmentSpread') {
-			// the application of the fragment has been validated already so track it
-			// so we can recreate
-			this.fragmentSpreads[selection.name.value] = selection
-
-			// find whether to include fragment fields
-			const houdiniDirective = selection.directives?.find(
-				({ name }) => name.value === this.config.houdiniDirective
-			)
-			const maskArgument = houdiniDirective?.arguments?.find(
-				({ name }) => name.value === 'mask'
-			)
-			let includeFragments = this.config.disableMasking
-			if (maskArgument?.value.kind === 'BooleanValue') {
-				includeFragments = !maskArgument.value.value
-			}
-
-			// we're finished if we're not supposed to include fragments in the selection
-			if (!includeFragments) {
-				return
-			}
-
-			const definition = this.fragmentDefinitions[selection.name.value]
-			if (!definition) {
-				throw new HoudiniError({
-					filepath: this.filepath,
-					message:
-						'Could not find referenced fragment definition: ' + selection.name.value,
-				})
-			}
-
-			for (const subselect of definition.selectionSet.selections) {
-				this.add(subselect)
-			}
-		}
-	}
-
-	toSelectionSet(): graphql.SelectionNode[] {
-		return Object.values(this.inlineFragments)
-			.map<graphql.SelectionNode>((fragment) => {
-				fragment.astNode.selectionSet.selections = fragment.selection.toSelectionSet()
-
-				return fragment.astNode
-			})
-			.concat(
-				Object.values(this.fields).map((field) => {
-					if (field.astNode.selectionSet) {
-						field.astNode.selectionSet.selections = field.selection.toSelectionSet()
-					}
-
-					return field.astNode
-				})
-			)
-			.concat(Object.values(this.fragmentSpreads))
-	}
-
-	empty() {
-		return new FieldCollection({
-			config: this.config,
-			fragmentDefinitions: this.fragmentDefinitions,
-			selections: [],
-			filepath: this.filepath,
-		})
-	}
-}
-
-type Field<_AST> = { astNode: _AST; selection: FieldCollection }

package/src/codegen/utils/graphql.test.ts

@@ -1,35 +0,0 @@
-import * as graphql from 'graphql'
-import { test, expect, describe } from 'vitest'
-
-import { testConfig } from '../../test'
-import { TypeWrapper, unwrapType } from './graphql'
-
-describe('unwrapType', () => {
-	test('list of lists', function () {
-		const type: graphql.TypeNode = {
-			kind: graphql.Kind.LIST_TYPE,
-			type: {
-				kind: graphql.Kind.NON_NULL_TYPE,
-				type: {
-					kind: graphql.Kind.NAMED_TYPE,
-					name: {
-						kind: graphql.Kind.NAME,
-						value: 'User',
-					},
-				},
-			},
-		}
-
-		const unwrapped = unwrapType(testConfig(), type)
-
-		// make sure we can get the inner type
-		expect(unwrapped.type.name).toEqual('User')
-
-		// and that we have the correct set of wrappers
-		expect(unwrapped.wrappers).toEqual([
-			TypeWrapper.NonNull,
-			TypeWrapper.List,
-			TypeWrapper.Nullable,
-		])
-	})
-})