houdini 0.17.9 → 0.17.11

package/src/codegen/generators/artifacts/utils.ts

@@ -1,108 +0,0 @@
-import type { ExpressionKind } from 'ast-types/gen/kinds'
-import * as graphql from 'graphql'
-import * as recast from 'recast'
-
-import { HoudiniError } from '../../../lib'
-
-const AST = recast.types.builders
-
-export function serializeValue(value: any): ExpressionKind {
-	// if we are serializing a list
-	if (Array.isArray(value)) {
-		// return an array expression with every element serialize
-		return AST.arrayExpression(value.map(serializeValue))
-	}
-
-	// if we are serializing an object
-	if (typeof value === 'object' && value !== null) {
-		return AST.objectExpression(
-			Object.entries(value)
-				.filter(([, value]) => typeof value !== 'undefined')
-				.map(([key, value]) =>
-					AST.objectProperty(AST.identifier(key), serializeValue(value))
-				)
-		)
-	}
-
-	// if we are serializing a string
-	if (typeof value === 'string') {
-		// if there are new lines, use a template. otherwise, just use a string
-		if (value.indexOf('\n') !== -1) {
-			return AST.templateLiteral(
-				[AST.templateElement({ raw: value, cooked: value }, true)],
-				[]
-			)
-		}
-		return AST.stringLiteral(value)
-	}
-
-	// anything else can just use its literal value
-	return AST.literal(value)
-}
-
-export function deepMerge(filepath: string, ...targets: {}[]): {} {
-	// look at the first target to know what type we're merging
-
-	// if we aren't looking at an object
-	if (typeof targets[0] !== 'object') {
-		// make sure all of the values are the same
-		const matches = targets.filter((val) => val !== targets[0]).length === 0
-		if (!matches) {
-			throw new HoudiniError({ filepath, message: 'could not merge: ' + targets })
-		}
-
-		// return the matching value
-		return targets[0]
-	}
-
-	// if we are looking at a list of lists
-	if (Array.isArray(targets[0])) {
-		return (targets[0] as {}[]).concat(...targets.slice(1))
-	}
-
-	// collect all of the fields that the targets specify and map them to their value
-	const fields: Record<string, any[]> = {}
-
-	for (const target of targets) {
-		// add every field of the target to the bag
-		for (const [key, value] of Object.entries(target)) {
-			// if we haven't seen the key before
-			if (!fields[key]) {
-				// save it as a list
-				fields[key] = []
-			}
-
-			fields[key].push(value)
-		}
-	}
-
-	return Object.fromEntries(
-		Object.entries(fields).map(([key, value]) => [key, deepMerge(filepath, ...value)])
-	)
-}
-
-export function convertValue(val: graphql.ValueNode) {
-	// figure out the value to use
-	let value
-	let kind
-
-	// the value of the arg is always going to be a
-	if (val.kind === graphql.Kind.INT) {
-		value = parseInt(val.value, 10)
-		kind = 'Int'
-	} else if (val.kind === graphql.Kind.FLOAT) {
-		value = parseFloat(val.value)
-		kind = 'Float'
-	} else if (val.kind === graphql.Kind.BOOLEAN) {
-		value = val.value
-		kind = 'Boolean'
-	} else if (val.kind === graphql.Kind.VARIABLE) {
-		value = val.name.value
-		kind = 'Variable'
-	} else if (val.kind === graphql.Kind.STRING) {
-		value = val.value
-		kind = 'String'
-	}
-
-	return { kind, value }
-}

package/src/codegen/generators/definitions/enums.test.ts

@@ -1,61 +0,0 @@
-import type { ProgramKind } from 'ast-types/gen/kinds'
-import * as recast from 'recast'
-import * as typeScriptParser from 'recast/parsers/typescript'
-import { test, expect } from 'vitest'
-
-import { runPipeline } from '../..'
-import { fs, CollectedGraphQLDocument, path } from '../../../lib'
-import { mockCollectedDoc, testConfig } from '../../../test'
-
-// the config to use in tests
-const config = testConfig()
-
-// the documents to test
-const docs: CollectedGraphQLDocument[] = [
-	mockCollectedDoc(`query TestQuery { version }`),
-	mockCollectedDoc(`fragment TestFragment on User { firstName }`),
-]
-
-test('generates runtime definitions for each enum', async function () {
-	// execute the generator
-	await runPipeline(config, [])
-
-	// load the contents of the type definitions file
-	let fileContents = await fs.readFile(path.join(config.enumTypesDefinitionsPath))
-	expect(fileContents).toBeTruthy()
-	let parsedQuery: ProgramKind = recast.parse(fileContents!.toString(), {
-		parser: typeScriptParser,
-	}).program
-
-	expect(parsedQuery).toMatchInlineSnapshot(`
-		export declare enum TestEnum1 {
-		    Value1 = "Value1",
-		    Value2 = "Value2"
-		}
-		 
-		export declare enum TestEnum2 {
-		    Value3 = "Value3",
-		    Value2 = "Value2"
-		}
-	`)
-
-	// load the contents of the type definitions file
-	fileContents = await fs.readFile(path.join(config.enumRuntimeDefinitionsPath))
-
-	expect(fileContents).toBeTruthy()
-	parsedQuery = recast.parse(fileContents!.toString(), {
-		parser: typeScriptParser,
-	}).program
-
-	expect(parsedQuery).toMatchInlineSnapshot(`
-		export const TestEnum1 = {
-		    "Value1": "Value1",
-		    "Value2": "Value2"
-		};
-
-		export const TestEnum2 = {
-		    "Value3": "Value3",
-		    "Value2": "Value2"
-		};
-	`)
-})

package/src/codegen/generators/definitions/enums.ts

@@ -1,68 +0,0 @@
-import * as graphql from 'graphql'
-import * as recast from 'recast'
-
-import { Config, fs, path } from '../../../lib'
-import { moduleExport } from '../../utils'
-
-const AST = recast.types.builders
-
-// the enum generator creates runtime definitions and centralizes the type definitions in a
-// single place to avoid conflicting exported types
-export default async function definitionsGenerator(config: Config) {
-	// grab every enum definition in the project's schema
-	const enums = (
-		graphql
-			.parse(graphql.printSchema(config.schema))
-			.definitions.filter(
-				(definition) => definition.kind === 'EnumTypeDefinition'
-			) as graphql.EnumTypeDefinitionNode[]
-	).filter((def) => !config.isInternalEnum(def))
-
-	// generate the runtime definitions
-	const runtimeDefinitions = recast.print(
-		AST.program(
-			enums.map((defn) => {
-				const name = defn.name.value
-
-				return moduleExport(
-					config,
-					name,
-					AST.objectExpression(
-						defn.values?.map((value) => {
-							const str = value.name.value
-							return AST.objectProperty(
-								AST.stringLiteral(str),
-								AST.stringLiteral(str)
-							)
-						}) || []
-					)
-				)
-			})
-		)
-	).code
-
-	// generate the type definitions
-	const typeDefinitions = enums
-		.sort((a, b) => a.name.value.localeCompare(b.name.value))
-		.map(
-			(definition) => `
-export declare enum ${definition.name.value} {
-${definition.values?.map((value) => `    ${value.name.value} = "${value.name.value}"`).join(',\n')}
-}
- `
-		)
-		.join('')
-
-	// the index file for the definitions directory
-	const definitionsIndex = `
-export * from './enums.js'
-	`
-
-	// write the typedefinition to disk
-	await Promise.all([
-		fs.writeFile(config.enumTypesDefinitionsPath, typeDefinitions),
-		fs.writeFile(config.enumRuntimeDefinitionsPath, runtimeDefinitions),
-		fs.writeFile(path.join(config.definitionsDirectory, 'index.js'), definitionsIndex),
-		fs.writeFile(path.join(config.definitionsDirectory, 'index.d.ts'), definitionsIndex),
-	])
-}

package/src/codegen/generators/definitions/index.ts

@@ -1,11 +0,0 @@
-import { Config, fs } from '../../../lib'
-import enums from './enums'
-
-// schemaGenerator updates the schema file to contain all of the generated
-export default async function schemaGenerator(config: Config) {
-	await Promise.all([
-		fs.writeFile(config.definitionsSchemaPath, config.newSchema),
-		fs.writeFile(config.definitionsDocumentsPath, config.newDocuments),
-		enums(config),
-	])
-}

package/src/codegen/generators/definitions/schema.test.ts

@@ -1,236 +0,0 @@
-// external
-import * as graphql from 'graphql'
-import { test, expect } from 'vitest'
-
-import { runPipeline } from '../..'
-import { CollectedGraphQLDocument, fs } from '../../../lib'
-import { mockCollectedDoc, testConfig } from '../../../test'
-
-const config = testConfig()
-
-test('adds internal documents to schema', async function () {
-	const docs: CollectedGraphQLDocument[] = [
-		mockCollectedDoc(`query TestQuery { version }`),
-		mockCollectedDoc(`fragment TestFragment on User { firstName }`),
-	]
-
-	// execute the generator
-	await runPipeline(config, docs)
-
-	// read the schema file and make sure it got the internal documents
-	expect(graphql.parse((await fs.readFile(config.definitionsSchemaPath))!))
-		.toMatchInlineSnapshot(`
-			enum CachePolicy {
-			  CacheAndNetwork
-			  CacheOnly
-			  CacheOrNetwork
-			  NetworkOnly
-			}
-
-			"""
-			@list is used to mark a field for the runtime as a place to add or remove
-			entities in mutations
-			"""
-			directive @list(name: String!, connection: Boolean) on FIELD
-
-			"""
-			@paginate is used to to mark a field for pagination.
-			More info in the [doc](https://houdinigraphql.com/guides/pagination).
-			"""
-			directive @paginate(name: String) on FIELD
-
-			"""@prepend is used to tell the runtime to add the result to the end of the list"""
-			directive @prepend(parentID: ID) on FRAGMENT_SPREAD
-
-			"""@append is used to tell the runtime to add the result to the start of the list"""
-			directive @append(parentID: ID) on FRAGMENT_SPREAD
-
-			"""@allLists is used to tell the runtime to add the result to all list"""
-			directive @allLists on FRAGMENT_SPREAD
-
-			"""
-			@parentID is used to provide a parentID without specifying position or in situations
-			where it doesn't make sense (eg when deleting a node.)
-			"""
-			directive @parentID(value: ID!) on FRAGMENT_SPREAD
-
-			"""@when is used to provide a conditional or in situations where it doesn't make sense (eg when removing or deleting a node.)"""
-			directive @when on FRAGMENT_SPREAD
-
-			"""@when_not is used to provide a conditional or in situations where it doesn't make sense (eg when removing or deleting a node.)"""
-			directive @when_not on FRAGMENT_SPREAD
-
-			"""@arguments is used to define the arguments of a fragment"""
-			directive @arguments on FRAGMENT_DEFINITION
-
-			"""@cache is used to specify cache rules for a query"""
-			directive @cache(policy: CachePolicy, partial: Boolean) on QUERY
-
-			"""@houdini is used to configure houdini's internal behavior"""
-			directive @houdini(
-			  """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! = true
-			) on QUERY | FRAGMENT_SPREAD
-		`)
-})
-
-test('list operations are included', async function () {
-	const docs: CollectedGraphQLDocument[] = [
-		mockCollectedDoc(
-			`query TestQuery { usersByCursor @list(name: "Friends") { edges { node { id } } } }`
-		),
-		mockCollectedDoc(`fragment TestFragment on User { firstName }`),
-	]
-
-	// execute the generator
-	await runPipeline(config, docs)
-
-	// read the schema file
-	expect(graphql.parse((await fs.readFile(config.definitionsSchemaPath))!))
-		.toMatchInlineSnapshot(`
-			enum CachePolicy {
-			  CacheAndNetwork
-			  CacheOnly
-			  CacheOrNetwork
-			  NetworkOnly
-			}
-
-			"""
-			@list is used to mark a field for the runtime as a place to add or remove
-			entities in mutations
-			"""
-			directive @list(name: String!, connection: Boolean) on FIELD
-
-			"""
-			@paginate is used to to mark a field for pagination.
-			More info in the [doc](https://houdinigraphql.com/guides/pagination).
-			"""
-			directive @paginate(name: String) on FIELD
-
-			"""@prepend is used to tell the runtime to add the result to the end of the list"""
-			directive @prepend(parentID: ID) on FRAGMENT_SPREAD
-
-			"""@append is used to tell the runtime to add the result to the start of the list"""
-			directive @append(parentID: ID) on FRAGMENT_SPREAD
-
-			"""@allLists is used to tell the runtime to add the result to all list"""
-			directive @allLists on FRAGMENT_SPREAD
-
-			"""
-			@parentID is used to provide a parentID without specifying position or in situations
-			where it doesn't make sense (eg when deleting a node.)
-			"""
-			directive @parentID(value: ID!) on FRAGMENT_SPREAD
-
-			"""@when is used to provide a conditional or in situations where it doesn't make sense (eg when removing or deleting a node.)"""
-			directive @when on FRAGMENT_SPREAD
-
-			"""@when_not is used to provide a conditional or in situations where it doesn't make sense (eg when removing or deleting a node.)"""
-			directive @when_not on FRAGMENT_SPREAD
-
-			"""@arguments is used to define the arguments of a fragment"""
-			directive @arguments on FRAGMENT_DEFINITION
-
-			"""@cache is used to specify cache rules for a query"""
-			directive @cache(policy: CachePolicy, partial: Boolean) on QUERY
-
-			"""@houdini is used to configure houdini's internal behavior"""
-			directive @houdini(
-			  """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! = true
-			) on QUERY | FRAGMENT_SPREAD
-
-			directive @User_delete repeatable on FIELD
-		`)
-
-	// read the documents file
-	expect(graphql.parse((await fs.readFile(config.definitionsDocumentsPath))!))
-		.toMatchInlineSnapshot(`
-		fragment Friends_insert on User {
-		  id
-		}
-
-		fragment Friends_toggle on User {
-		  id
-		  id
-		}
-
-		fragment Friends_remove on User {
-		  id
-		}
-
-	`)
-})
-
-test("writing twice doesn't duplicate definitions", async function () {
-	const docs: CollectedGraphQLDocument[] = [
-		mockCollectedDoc(`query TestQuery { version }`),
-		mockCollectedDoc(`fragment TestFragment on User { firstName }`),
-	]
-
-	// execute the generator twice
-	await runPipeline(config, docs)
-	await runPipeline(config, docs)
-
-	// read the schema file and make sure it got the internal documents
-	expect(graphql.parse((await fs.readFile(config.definitionsSchemaPath))!))
-		.toMatchInlineSnapshot(`
-			enum CachePolicy {
-			  CacheAndNetwork
-			  CacheOnly
-			  CacheOrNetwork
-			  NetworkOnly
-			}
-
-			"""
-			@list is used to mark a field for the runtime as a place to add or remove
-			entities in mutations
-			"""
-			directive @list(name: String!, connection: Boolean) on FIELD
-
-			"""
-			@paginate is used to to mark a field for pagination.
-			More info in the [doc](https://houdinigraphql.com/guides/pagination).
-			"""
-			directive @paginate(name: String) on FIELD
-
-			"""@prepend is used to tell the runtime to add the result to the end of the list"""
-			directive @prepend(parentID: ID) on FRAGMENT_SPREAD
-
-			"""@append is used to tell the runtime to add the result to the start of the list"""
-			directive @append(parentID: ID) on FRAGMENT_SPREAD
-
-			"""@allLists is used to tell the runtime to add the result to all list"""
-			directive @allLists on FRAGMENT_SPREAD
-
-			"""
-			@parentID is used to provide a parentID without specifying position or in situations
-			where it doesn't make sense (eg when deleting a node.)
-			"""
-			directive @parentID(value: ID!) on FRAGMENT_SPREAD
-
-			"""@when is used to provide a conditional or in situations where it doesn't make sense (eg when removing or deleting a node.)"""
-			directive @when on FRAGMENT_SPREAD
-
-			"""@when_not is used to provide a conditional or in situations where it doesn't make sense (eg when removing or deleting a node.)"""
-			directive @when_not on FRAGMENT_SPREAD
-
-			"""@arguments is used to define the arguments of a fragment"""
-			directive @arguments on FRAGMENT_DEFINITION
-
-			"""@cache is used to specify cache rules for a query"""
-			directive @cache(policy: CachePolicy, partial: Boolean) on QUERY
-
-			"""@houdini is used to configure houdini's internal behavior"""
-			directive @houdini(
-			  """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! = true
-			) on QUERY | FRAGMENT_SPREAD
-		`)
-})

package/src/codegen/generators/index.ts

@@ -1,6 +0,0 @@
-export { default as artifacts } from './artifacts'
-export { default as runtime } from './runtime'
-export { default as typescript } from './typescript'
-export { default as persistOutput } from './persistedQueries'
-export { default as definitions } from './definitions'
-export { default as indexFile } from './indexFile'

package/src/codegen/generators/indexFile/index.ts

@@ -1,63 +0,0 @@
-// locals
-import { Config, CollectedGraphQLDocument, fs, path } from '../../../lib'
-import { cjsIndexFilePreamble, exportStarFrom, exportDefaultFrom } from '../../utils'
-
-// every document in the application should be re-exported from the root. this allows the user to balance
-// code-splitting concerns with the "cleanliness" of importing from a single location
-export default async function writeIndexFile(config: Config, docs: CollectedGraphQLDocument[]) {
-	const relative = (target: string) => './' + path.relative(config.rootDir, target)
-
-	// the directories we want to export
-	const runtimeDir = relative(config.runtimeDirectory)
-	const artifactDir = relative(config.artifactDirectory)
-	const definitionsDir = relative(config.definitionsDirectory)
-
-	// if we are rendering an index file for sapper we need to compile it for commonjs
-	const cjs = config.module === 'commonjs'
-	let body = cjs ? cjsIndexFilePreamble : ''
-
-	// create the export functions
-	const export_star_from = ({ module }: { module: string }) =>
-		'\n' + (cjs ? exportStarFrom(module) : `export * from "${module}"`) + '\n'
-	const export_default_as = ({ module, as }: { module: string; as: string }) =>
-		'\n' +
-		(cjs ? exportDefaultFrom(module, as) : `export { default as ${as} } from "${module}"`) +
-		'\n'
-
-	// add the standard exports
-	body += [
-		export_star_from({ module: runtimeDir }),
-		export_star_from({ module: artifactDir }),
-		export_star_from({ module: definitionsDir }),
-	].join('')
-
-	// plugins can influence the index file
-	for (const plugin of config.plugins) {
-		// if they need to add stuff directly (from directories that were generated)
-		if (plugin.index_file) {
-			body = plugin.index_file({
-				config,
-				content: body,
-				export_default_as,
-				export_star_from,
-				plugin_root: config.pluginDirectory(plugin.name),
-				typedef: false,
-				documents: docs,
-			})
-		}
-
-		// if the plugin generated a runtime
-		if (plugin.include_runtime) {
-			body += export_star_from({
-				module: relative(config.pluginRuntimeDirectory(plugin.name)),
-			})
-		}
-
-		if (!plugin.index_file) {
-			continue
-		}
-	}
-
-	// write the index file that exports the runtime
-	await fs.writeFile(path.join(config.rootDir, 'index.js'), body)
-}

package/src/codegen/generators/indexFile/indexFile.test.ts

@@ -1,72 +0,0 @@
-import type { ProgramKind } from 'ast-types/gen/kinds'
-import * as recast from 'recast'
-import * as typeScriptParser from 'recast/parsers/typescript'
-import { test, expect } from 'vitest'
-
-import { runPipeline } from '../..'
-import { fs, CollectedGraphQLDocument, path } from '../../../lib'
-import { mockCollectedDoc, testConfig } from '../../../test'
-
-// the config to use in tests
-const config = testConfig()
-
-// the documents to test
-const docs: CollectedGraphQLDocument[] = [
-	mockCollectedDoc(`query TestQuery { version }`),
-	mockCollectedDoc(`fragment TestFragment on User { firstName }`),
-]
-
-test('index file - esm', async function () {
-	const config = testConfig({ module: 'esm' })
-
-	// execute the generator
-	await runPipeline(config, docs)
-
-	// open up the index file
-	const queryContents = await fs.readFile(path.join(config.artifactDirectory, 'index.js'))
-	expect(queryContents).toBeTruthy()
-	// parse the contents
-	const parsedQuery: ProgramKind = recast.parse(queryContents!, {
-		parser: typeScriptParser,
-	}).program
-	// verify contents
-	expect(parsedQuery).toMatchInlineSnapshot(`
-		export { default as TestFragment} from './TestFragment'
-		export { default as TestQuery} from './TestQuery'
-	`)
-})
-
-test('index file - commonjs', async function () {
-	// execute the generator
-	await runPipeline(testConfig({ module: 'commonjs' }), docs)
-
-	// open up the index file
-	const queryContents = await fs.readFile(path.join(config.artifactDirectory, 'index.js'))
-	expect(queryContents).toBeTruthy()
-	// parse the contents
-	const parsedQuery: ProgramKind = recast.parse(queryContents!, {
-		parser: typeScriptParser,
-	}).program
-	// verify contents
-	expect(parsedQuery).toMatchInlineSnapshot(`
-		"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 });
-		var TestFragment = require("./TestFragment");
-		Object.defineProperty(exports, "TestFragment", { enumerable: true, get: function () { return __importDefault(TestFragment).default; } });
-		var TestQuery = require("./TestQuery");
-		Object.defineProperty(exports, "TestQuery", { enumerable: true, get: function () { return __importDefault(TestQuery).default; } });
-	`)
-})

package/src/codegen/generators/persistedQueries/index.ts

@@ -1,55 +0,0 @@
-//externals
-import * as graphql from 'graphql'
-
-// internals
-import { Config, hashDocument, fs, CollectedGraphQLDocument } from '../../../lib'
-
-// the persist output generator is responsible for generating a queryMap.json
-// to the provided path with the `hash` as key and the raw query as value.
-export default async function persistOutputGenerator(
-	config: Config,
-	docs: CollectedGraphQLDocument[]
-) {
-	if (typeof config.persistedQueryPath !== 'string' || config.persistedQueryPath.length === 0)
-		return
-
-	if (!config.persistedQueryPath.endsWith('.json')) {
-		console.log('Can only write the queryMap to a json file')
-		return
-	}
-
-	const queryMap = docs.reduce<Record<string, string>>((acc, { document, generateArtifact }) => {
-		// if the document is generated, just return early since there is no operation
-		if (!generateArtifact) {
-			return acc
-		}
-
-		// Strip all references to internal directives
-		let rawString = graphql.print(
-			graphql.visit(document, {
-				Directive(node) {
-					// if the directive is one of the internal ones, remove it
-					if (config.isInternalDirective(node)) {
-						return null
-					}
-				},
-			})
-		)
-
-		const operations = document.definitions.filter(
-			({ kind }) => kind === graphql.Kind.OPERATION_DEFINITION
-		) as graphql.OperationDefinitionNode[]
-
-		// if there are operations in the document
-		if (operations.length > 0 && operations[0].kind === 'OperationDefinition') {
-			acc[hashDocument(rawString)] = rawString
-		}
-
-		return acc
-	}, {})
-
-	if (Object.keys(queryMap).length === 0) return
-
-	// Write the queryMap to the provided path
-	await fs.writeFile(config.persistedQueryPath, JSON.stringify(queryMap, null, 4))
-}